6502/kickc
1
0
Fork 0
mirror of https://gitlab.com/camelot/kickc.git synced 2025-04-05 07:40:39 +00:00
Code Issues Projects Releases Wiki Activity

Implemented live ranged based register allocation - coalescing on phi statements first, copy-assignments second, other assignments third - and finally the remaining vars are added.

Browse Source
This commit is contained in:
jespergravgaard 2017-07-27 01:33:10 +02:00
parent 13c84a1741
commit be212f3b38
26 changed files with 1711 additions and 1333 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
.idea/codeStyleSettings.xml generated Normal file
View File

@ -0,0 +1,9 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectCodeStyleSettingsManager">
<option name="PER_PROJECT_SETTINGS">
<value />
</option>
<option name="PREFERRED_PROJECT_CODE_STYLE" value="Default (1)" />
</component>
</project>

41
.idea/misc.xml generated
View File

@ -1,46 +1,5 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectInspectionProfilesVisibleTreeState">
<entry key="Project Default">
<profile-state>
<expanded-state>
<State>
<id />
</State>
<State>
<id>Android Lint</id>
</State>
<State>
<id>Compiler issuesJava</id>
</State>
<State>
<id>GPath inspectionsGroovy</id>
</State>
<State>
<id>Groovy</id>
</State>
<State>
<id>Internationalization issues</id>
</State>
<State>
<id>Java</id>
</State>
<State>
<id>Performance issuesJava</id>
</State>
<State>
<id>Portability issuesJava</id>
</State>
<State>
<id>Properties Files</id>
</State>
<State>
<id>Properties FilesJava</id>
</State>
</expanded-state>
</profile-state>
</entry>
</component>
<component name="ProjectRootManager" version="2" languageLevel="JDK_1_7" default="true" project-jdk-name="1.7" project-jdk-type="JavaSDK">
<output url="file://$PROJECT_DIR$/out" />
</component>

6
src/dk/camelot64/kickc/Compiler.java
View File

@ -85,8 +85,10 @@ public class Compiler {
}
public AsmProgram pass4GenerateAsm(Program program, CompileLog log) {
Pass4RegisterAllocation pass4RegisterAllocation = new Pass4RegisterAllocation(program);
pass4RegisterAllocation.allocate();
Pass4ZeroPageAllocationLiveRange pass4ZeroPageAllocationLiveRange = new Pass4ZeroPageAllocationLiveRange(program, log);
pass4ZeroPageAllocationLiveRange.allocate();
Pass4CodeGeneration pass4CodeGeneration = new Pass4CodeGeneration(program);
AsmProgram asmProgram = pass4CodeGeneration.generate();

94
src/dk/camelot64/kickc/icl/LiveRangeEquivalenceClass.java Normal file
View File

@ -0,0 +1,94 @@
package dk.camelot64.kickc.icl;
import java.util.ArrayList;
import java.util.List;
/**
* A live range equivalence class contains a set of variables with non-overlapping live ranges.
**/
public class LiveRangeEquivalenceClass {
/** The containing program. */
private Program program;
/** The variables of the equivalence class. */
private List<VariableRef> variables;
/** The combined live range of the variables. */
private LiveRange classLiveRange;
public LiveRangeEquivalenceClass(Program program) {
this.program = program;
this.variables = new ArrayList<>();
this.classLiveRange = new LiveRange();
}
/**
* Add a variable to the equivalence class
*
* @param variable The variable to add
*/
public void addVariable(VariableRef variable) {
if(variables.contains(variable)) {
return;
}
VariableLiveRanges liveRanges = program.getScope().getLiveRanges();
LiveRange varLiveRange = liveRanges.getLiveRange(variable);
if (classLiveRange.overlaps(varLiveRange)) {
throw new RuntimeException("Compilation error! Variable live range overlaps live range equivalence class live range. " + variable);
}
classLiveRange.add(varLiveRange);
variables.add(variable);
}
/**
* Determines if the phi equivalence class contains a variable
*
* @param variable The variable to look for
* @return true if the equivalence class contains the variable
*/
public boolean contains(VariableRef variable) {
return variables.contains(variable);
}
public LiveRange getLiveRange() {
return classLiveRange;
}
public void addAll(LiveRangeEquivalenceClass other) {
variables.addAll(other.variables);
classLiveRange.add(other.classLiveRange);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
LiveRangeEquivalenceClass that = (LiveRangeEquivalenceClass) o;
return variables.equals(that.variables);
}
@Override
public int hashCode() {
return variables.hashCode();
}
@Override
public String toString() {
StringBuilder s = new StringBuilder();
s.append("[ ");
for (VariableRef variable : variables) {
s.append(variable.toString());
s.append(" ");
}
s.append("]");
return s.toString();
}
public List<VariableRef> getVariables() {
return variables;
}
}

64
src/dk/camelot64/kickc/icl/LiveRangeEquivalenceClassSet.java Normal file
View File

@ -0,0 +1,64 @@
package dk.camelot64.kickc.icl;
import java.util.ArrayList;
import java.util.List;
/** A set of live range equivalence classes. */
public class LiveRangeEquivalenceClassSet {
private Program program;
private List<LiveRangeEquivalenceClass> equivalenceClasses;
public LiveRangeEquivalenceClassSet(Program program) {
this.program = program;
this.equivalenceClasses = new ArrayList<>();
}
/**
* Get the phi equivalence class for a specific variable.
* If the equivalence class does not exist it is created.
*
* @param variable The variable
* @return The existing or new phi equivalence class
*/
public LiveRangeEquivalenceClass getOrCreateEquivalenceClass(VariableRef variable) {
LiveRangeEquivalenceClass equivalenceClass = getEquivalenceClass(variable);
if (equivalenceClass != null) {
return equivalenceClass;
}
// Not found - create it
equivalenceClass = new LiveRangeEquivalenceClass(program);
equivalenceClasses.add(equivalenceClass);
equivalenceClass.addVariable(variable);
return equivalenceClass;
}
/**
* Get the phi equivalence class for a specific variable.
*
* @param variable The variable
* @return The existing phi equivalence class. null if no equivalence class contains the variable.
*/
public LiveRangeEquivalenceClass getEquivalenceClass(VariableRef variable) {
for (LiveRangeEquivalenceClass equivalenceClass : equivalenceClasses) {
if (equivalenceClass.contains(variable)) {
return equivalenceClass;
}
}
return null;
}
public List<LiveRangeEquivalenceClass> getEquivalenceClasses() {
return equivalenceClasses;
}
public int size() {
return equivalenceClasses.size();
}
public void remove(LiveRangeEquivalenceClass equivalenceClass) {
equivalenceClasses.remove(equivalenceClass);
}
}

18
src/dk/camelot64/kickc/icl/RegisterAllocation.java
View File

@ -8,7 +8,7 @@ import java.util.Map;
/** Register Allocation for Variable Symbols */
public class RegisterAllocation {
private Map<String, Register> allocation;
private Map<VariableRef, Register> allocation;
public RegisterAllocation() {
this.allocation = new LinkedHashMap<>();
@ -21,17 +21,17 @@ public class RegisterAllocation {
* @return The allocated register.
*/
public Register getRegister(Variable variable) {
return allocation.get(variable.getFullName());
return allocation.get(variable.getRef());
}
public Register getRegister(String varFullName) {
return allocation.get(varFullName);
public Register getRegister(VariableRef ref) {
return allocation.get(ref);
}
public void allocate(Variable variable, Register register) {
public void allocate(VariableRef variable, Register register) {
if(variable!=null) {
allocation.put(variable.getFullName(), register);
allocation.put(variable, register);
}
}
@ -342,9 +342,9 @@ public class RegisterAllocation {
@Override
public String toString() {
StringBuffer out = new StringBuffer();
for (String varName: allocation.keySet()) {
Register register = getRegister(varName);
out.append(varName+" : "+register+"\n");
for (VariableRef var: allocation.keySet()) {
Register register = getRegister(var);
out.append(var.toString()+" : "+register.toString()+"\n");
}
return out.toString();
}

18
src/dk/camelot64/kickc/passes/Pass2SsaOptimization.java
View File

@ -12,13 +12,11 @@ import java.util.*;
public abstract class Pass2SsaOptimization {
protected CompileLog log;
private ControlFlowGraph graph;
private ProgramScope scope;
private Program program;
public Pass2SsaOptimization(Program program,CompileLog log) {
this.program = program;
this.log = log;
this.graph = program.getGraph();
this.scope = program.getScope();
}
public CompileLog getLog() {
@ -26,11 +24,15 @@ public abstract class Pass2SsaOptimization {
}
public ControlFlowGraph getGraph() {
return graph;
return program.getGraph();
}
public ProgramScope getSymbols() {
return scope;
return program.getScope();
}
public Program getProgram() {
return program;
}
/**
@ -167,7 +169,7 @@ public abstract class Pass2SsaOptimization {
}
};
visitor.visitGraph(graph);
visitor.visitGraph(getGraph());
}
/**
@ -251,7 +253,7 @@ public abstract class Pass2SsaOptimization {
* @param variables The variables to eliminate
*/
public void removeAssignments(Collection<? extends LValue> variables) {
for (ControlFlowBlock block : graph.getAllBlocks()) {
for (ControlFlowBlock block : getGraph().getAllBlocks()) {
for (Iterator<Statement> iterator = block.getStatements().iterator(); iterator.hasNext(); ) {
Statement statement = iterator.next();
if (statement instanceof StatementAssignment) {

185
src/dk/camelot64/kickc/passes/Pass3PhiMemCoalesce.java
View File

@ -12,7 +12,14 @@ import java.util.Map;
* Eliminate virtual variables introduced by PhiLifting if they do not have overlapping live ranges with other phi equivalent variables.
* (This pass requires variable alive ranges).
* <p>
* This utilized live range equivalence classes over the phi statements of the program.
* In the phi statement <code>va = phi(vb, vc)</code> all 3 variables are in the same equivalence class.
* The equivalence class is the closure over all phi statements in the program.
* The set of equivalence classes is a disjoint partition of all variables uses in phi statements
* (ie. those variables crossing non-trivial block transitions).
* <p>
* See http://compilers.cs.ucla.edu/fernando/projects/soc/reports/short_tech.pdf
*
*/
public class Pass3PhiMemCoalesce extends Pass2SsaOptimization {
@ -22,28 +29,28 @@ public class Pass3PhiMemCoalesce extends Pass2SsaOptimization {
@Override
public boolean optimize() {
PhiEquivalenceClassInitializer phiEquivalenceClassInitializer = new PhiEquivalenceClassInitializer();
phiEquivalenceClassInitializer.visitGraph(getGraph());
ProgramPhiEquivalenceClasses phiEquivalenceClasses = phiEquivalenceClassInitializer.getPhiEquivalenceClasses();
log.append("Created " +phiEquivalenceClasses.size()+ " initial phi equivalence classes");
EquivalenceClassPhiInitializer equivalenceClassPhiInitializer = new EquivalenceClassPhiInitializer(getProgram());
equivalenceClassPhiInitializer.visitGraph(getGraph());
LiveRangeEquivalenceClassSet phiEquivalenceClasses = equivalenceClassPhiInitializer.getPhiEquivalenceClasses();
log.append("Created " + phiEquivalenceClasses.size() + " initial phi equivalence classes");
PhiMemCoalescer phiMemCoalescer = new PhiMemCoalescer(phiEquivalenceClasses);
phiMemCoalescer.visitGraph(getGraph());
removeAssignments(phiMemCoalescer.getRemove());
replaceVariables(phiMemCoalescer.getReplace());
deleteVariables(phiMemCoalescer.getRemove());
log.append("Coalesced down to " +phiEquivalenceClasses.size()+ " phi equivalence classes");
log.append("Coalesced down to " + phiEquivalenceClasses.size() + " phi equivalence classes");
return false;
}
/** Coalesces phi equivalence classes when they do not overlap based on assignments to variables in phi statements. */
private class PhiMemCoalescer extends ControlFlowGraphBaseVisitor<Void> {
private ProgramPhiEquivalenceClasses phiEquivalenceClasses;
private LiveRangeEquivalenceClassSet phiEquivalenceClassSet;
private List<VariableRef> remove;
private Map<VariableRef, VariableRef> replace;
public PhiMemCoalescer(ProgramPhiEquivalenceClasses phiEquivalenceClasses) {
this.phiEquivalenceClasses = phiEquivalenceClasses;
public PhiMemCoalescer(LiveRangeEquivalenceClassSet phiEquivalenceClassSet) {
this.phiEquivalenceClassSet = phiEquivalenceClassSet;
this.remove = new ArrayList<>();
this.replace = new HashMap<>();
}
@ -59,24 +66,24 @@ public class Pass3PhiMemCoalesce extends Pass2SsaOptimization {
@Override
public Void visitAssignment(StatementAssignment assignment) {
if (assignment.getlValue() instanceof VariableRef) {
PhiEquivalenceClass lValEquivalenceClass =
phiEquivalenceClasses.getPhiEquivalenceClass((VariableRef) assignment.getlValue());
LiveRangeEquivalenceClass lValEquivalenceClass =
phiEquivalenceClassSet.getEquivalenceClass((VariableRef) assignment.getlValue());
if (lValEquivalenceClass != null && assignment.getOperator() == null && assignment.getrValue1() == null && assignment.getrValue2() instanceof VariableRef) {
// Found copy assignment to a variable in an equivalence class - attempt to coalesce
VariableRef assignVar = (VariableRef) assignment.getrValue2();
PhiEquivalenceClass assignVarEquivalenceClass = phiEquivalenceClasses.getOrCreateEquivalenceClass(assignVar);
if(lValEquivalenceClass.equals(assignVarEquivalenceClass)) {
LiveRangeEquivalenceClass assignVarEquivalenceClass = phiEquivalenceClassSet.getOrCreateEquivalenceClass(assignVar);
if (lValEquivalenceClass.equals(assignVarEquivalenceClass)) {
remove.add((VariableRef) assignment.getlValue());
replace.put((VariableRef) assignment.getlValue(), assignVar);
log.append("Coalesced (already) "+assignment);
log.append("Coalesced (already) " + assignment);
} else if (!lValEquivalenceClass.getLiveRange().overlaps(assignVarEquivalenceClass.getLiveRange())) {
lValEquivalenceClass.addAll(assignVarEquivalenceClass);
phiEquivalenceClasses.remove(assignVarEquivalenceClass);
phiEquivalenceClassSet.remove(assignVarEquivalenceClass);
remove.add((VariableRef) assignment.getlValue());
replace.put((VariableRef) assignment.getlValue(), assignVar);
log.append("Coalesced "+assignment);
log.append("Coalesced " + assignment);
} else {
log.append("Not coalescing "+assignment);
log.append("Not coalescing " + assignment);
}
}
}
@ -85,155 +92,39 @@ public class Pass3PhiMemCoalesce extends Pass2SsaOptimization {
}
/**
* Creates initial live range equivalence classes from program phi statements.
*/
public static class EquivalenceClassPhiInitializer extends ControlFlowGraphBaseVisitor<Void> {
/** Creates initial phi equivalence classes from program phi statements.*/
private class PhiEquivalenceClassInitializer extends ControlFlowGraphBaseVisitor<Void> {
private LiveRangeEquivalenceClassSet phiEquivalenceClasses;
private ProgramPhiEquivalenceClasses phiEquivalenceClasses;
public PhiEquivalenceClassInitializer() {
this.phiEquivalenceClasses = new ProgramPhiEquivalenceClasses();
public EquivalenceClassPhiInitializer(Program program) {
this.phiEquivalenceClasses = new LiveRangeEquivalenceClassSet(program);
}
@Override
public Void visitPhiBlock(StatementPhiBlock phi) {
for (StatementPhiBlock.PhiVariable phiVariable : phi.getPhiVariables()) {
VariableRef variable = phiVariable.getVariable();
PhiEquivalenceClass equivalenceClass = phiEquivalenceClasses.getOrCreateEquivalenceClass(variable);
LiveRangeEquivalenceClass equivalenceClass = phiEquivalenceClasses.getOrCreateEquivalenceClass(variable);
for (StatementPhiBlock.PhiRValue phiRValue : phiVariable.getValues()) {
if(!(phiRValue.getrValue() instanceof Constant)) {
if (!(phiRValue.getrValue() instanceof Constant)) {
VariableRef phiRVar = (VariableRef) phiRValue.getrValue();
equivalenceClass.addVariable(phiRVar);
LiveRangeEquivalenceClass rValEquivalenceClass = phiEquivalenceClasses.getOrCreateEquivalenceClass(phiRVar);
if(!rValEquivalenceClass.equals(equivalenceClass)) {
equivalenceClass.addAll(rValEquivalenceClass);
phiEquivalenceClasses.remove(rValEquivalenceClass);
}
}
}
}
return null;
}
public ProgramPhiEquivalenceClasses getPhiEquivalenceClasses() {
public LiveRangeEquivalenceClassSet getPhiEquivalenceClasses() {
return phiEquivalenceClasses;
}
}
/** The entire set of phi equivalence classes in the pgogram. */
public class ProgramPhiEquivalenceClasses {
List<PhiEquivalenceClass> equivalenceClasses;
public ProgramPhiEquivalenceClasses() {
this.equivalenceClasses = new ArrayList<>();
}
/**
* Get the phi equivalence class for a specific variable.
* If the equivalence class does not exist it is created.
*
* @param variable The variable
* @return The existing or new phi equivalence class
*/
public PhiEquivalenceClass getOrCreateEquivalenceClass(VariableRef variable) {
PhiEquivalenceClass equivalenceClass1 = getPhiEquivalenceClass(variable);
if (equivalenceClass1 != null) return equivalenceClass1;
// Not found - create it
PhiEquivalenceClass equivalenceClass = new PhiEquivalenceClass();
equivalenceClasses.add(equivalenceClass);
equivalenceClass.addVariable(variable);
return equivalenceClass;
}
/**
* Get the phi equivalence class for a specific variable.
*
* @param variable The variable
* @return The existing phi equivalence class. null if no equivalence class contains the variable.
*/
private PhiEquivalenceClass getPhiEquivalenceClass(VariableRef variable) {
for (PhiEquivalenceClass equivalenceClass : equivalenceClasses) {
if(equivalenceClass.contains(variable)) {
return equivalenceClass;
}
}
return null;
}
public int size() {
return equivalenceClasses.size();
}
public void remove(PhiEquivalenceClass equivalenceClass) {
equivalenceClasses.remove(equivalenceClass);
}
}
/**
* A phi equivalence class contains all varialbes connected in by phi statements.
* In the phi statement <code>va = phi(vb, vc)</code> all 3 variables are in the same equivalence class.
* The equivalence class is the closure over all phi statements in the program.
* The set of equivalence classes is a disjoint partition of all variables uses in phi statements
* (ie. those variables crossing non-trivial block transitions).
* <p>
* See http://compilers.cs.ucla.edu/fernando/projects/soc/reports/short_tech.pdf
**/
public class PhiEquivalenceClass {
/** The variables of the equivalence class. */
List<VariableRef> variables;
/** The combined live range of the variables. */
LiveRange classLiveRange;
public PhiEquivalenceClass() {
this.variables = new ArrayList<>();
this.classLiveRange = new LiveRange();
}
/**
* Add a variable to the equivalence class
* @param variable The variable to add
*/
public void addVariable(VariableRef variable) {
VariableLiveRanges liveRanges = getSymbols().getLiveRanges();
LiveRange varLiveRange = liveRanges.getLiveRange(variable);
if(classLiveRange.overlaps(varLiveRange)) {
throw new RuntimeException("Compilation error! Variable live range overlaps phi equivalence class live range. "+variable);
}
classLiveRange.add(varLiveRange);
variables.add(variable);
}
/**
* Determines if the phi equivalence class contains a variable
* @param variable The variable to look for
* @return true if the equivalence class contains the variable
*/
public boolean contains(VariableRef variable) {
return variables.contains(variable);
}
public LiveRange getLiveRange() {
return classLiveRange;
}
public void addAll(PhiEquivalenceClass other) {
variables.addAll(other.variables);
classLiveRange.add(other.classLiveRange);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
PhiEquivalenceClass that = (PhiEquivalenceClass) o;
return variables.equals(that.variables);
}
@Override
public int hashCode() {
return variables.hashCode();
}
}
}

186
src/dk/camelot64/kickc/passes/Pass4RegisterAllocation.java
View File

@ -1,186 +0,0 @@
package dk.camelot64.kickc.passes;
import dk.camelot64.kickc.icl.*;
/**
* Register Allocation for variables
*/
public class Pass4RegisterAllocation {
private ControlFlowGraph graph;
private ProgramScope symbols;
int currentZp = 2;
public Pass4RegisterAllocation(Program program) {
this.graph = program.getGraph();
this.symbols = program.getScope();
}
public void allocate() {
RegisterAllocation allocation = new RegisterAllocation();
performAllocation(symbols, allocation);
//allocation.allocate(symbols.getVariable("i#0"), RegisterAllocation.getRegisterX());
//allocation.allocate(symbols.getVariable("i#3"), RegisterAllocation.getRegisterX());
//allocation.allocate(symbols.getVariable("i#4"), RegisterAllocation.getRegisterX());
//allocation.allocate(symbols.getVariable("i#5"), RegisterAllocation.getRegisterX());
//allocation.allocate(symbols.getVariable("i#6"), RegisterAllocation.getRegisterX());
//allocation.allocate(symbols.getVariable("i#7"), RegisterAllocation.getRegisterX());
//allocation.allocate(symbols.getVariable("n1#1"), RegisterAllocation.getRegisterY());
//allocation.allocate(symbols.getVariable("n1#2"), RegisterAllocation.getRegisterY());
//allocation.allocate(symbols.getVariable("e#2"), new RegisterAllocation.RegisterZpByte(128));
//allocation.allocate(symbols.getVariable("e#3"), new RegisterAllocation.RegisterZpByte(128));
//allocation.allocate(symbols.getVariable("e#4"), new RegisterAllocation.RegisterZpByte(128));
//allocation.allocate(symbols.getVariable("e#5"), new RegisterAllocation.RegisterZpByte(128));
//allocation.allocate(symbols.getVariable("idx#2"), new RegisterAllocation.RegisterZpWord(129));
//allocation.allocate(symbols.getVariable("idx#3"), new RegisterAllocation.RegisterZpWord(129));
//allocation.allocate(symbols.getVariable("idx#4"), new RegisterAllocation.RegisterZpWord(129));
//allocation.allocate(symbols.getVariable("idx#5"), new RegisterAllocation.RegisterZpWord(129));
//allocation.allocate(symbols.getVariable("x#0"), new RegisterAllocation.RegisterYByte());
//allocation.allocate(symbols.getVariable("x#1"), new RegisterAllocation.RegisterYByte());
//allocation.allocate(symbols.getVariable("x#2"), new RegisterAllocation.RegisterYByte());
//allocation.allocate(symbols.getVariable("x#5"), new RegisterAllocation.RegisterZpByte(131));
//allocation.allocate(symbols.getVariable("y#0"), new RegisterAllocation.RegisterZpByte(132));
//allocation.allocate(symbols.getVariable("y#1"), new RegisterAllocation.RegisterZpByte(132));
//allocation.allocate(symbols.getVariable("y#2"), new RegisterAllocation.RegisterZpByte(132));
//allocation.allocate(symbols.getVariable("y#5"), new RegisterAllocation.RegisterZpByte(132));
//allocation.allocate(symbols.getVariable("cursor#2"), new RegisterAllocation.RegisterZpPointerByte(133));
//allocation.allocate(symbols.getVariable("cursor#3"), new RegisterAllocation.RegisterZpPointerByte(133));
//allocation.allocate(symbols.getVariable("cursor#4"), new RegisterAllocation.RegisterZpPointerByte(133));
//allocation.allocate(symbols.getVariable("cursor#5"), new RegisterAllocation.RegisterZpPointerByte(133));
//allocation.allocate(symbols.getVariable("ptr#1"), new RegisterAllocation.RegisterZpPointerByte(135));
//allocation.allocate(symbols.getVariable("ptr#2"), new RegisterAllocation.RegisterZpPointerByte(135));
//allocation.allocate(symbols.getVariable("ptr#3"), new RegisterAllocation.RegisterZpPointerByte(135));
//allocation.allocate(symbols.getVariable("v#1"), new RegisterAllocation.RegisterAByte());
//allocation.allocate(symbols.getVariable("v#2"), new RegisterAllocation.RegisterAByte());
//allocation.allocate(symbols.getVariable("v#3"), new RegisterAllocation.RegisterAByte());
//allocation.allocate(symbols.getVariable("v#4"), new RegisterAllocation.RegisterAByte());
//allocation.allocate(symbols.getVariable("v#5"), new RegisterAllocation.RegisterAByte());
//allocation.allocate(symbols.getVariable("$0"), new RegisterAllocation.RegisterAByte());
//allocation.allocate(symbols.getVariable("$2"), new RegisterAllocation.RegisterAByte());
//allocation.allocate(symbols.getVariable("$3"), new RegisterAllocation.RegisterAByte());
//allocation.allocate(symbols.getVariable("$5"), new RegisterAllocation.RegisterAByte());
//allocation.allocate(symbols.getVariable("$6"), new RegisterAllocation.RegisterALUByte());
//allocation.allocate(symbols.getVariable("$7"), new RegisterAllocation.RegisterAByte());
//allocation.allocate(symbols.getVariable("inc::a#2"), new RegisterAllocation.RegisterAByte());
//allocation.allocate(symbols.getVariable("bv#0"), new RegisterAllocation.RegisterAByte());
//allocation.allocate(symbols.getVariable("sum::b#0"), new RegisterAllocation.RegisterAByte());
//allocation.allocate(symbols.getVariable("inc::b#1"), new RegisterAllocation.RegisterAByte());
//allocation.allocate(symbols.getVariable("a#1"), new RegisterAllocation.RegisterAByte());
//allocation.allocate(symbols.getVariable("a#0"), new RegisterAllocation.RegisterAByte());
// Register allocation for fibmem.kc
/*
allocation.allocate(symbols.getVariable("i#1"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("i#2"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("$1"), new RegisterAllocation.RegisterAByte());
allocation.allocate(symbols.getVariable("$3"), new RegisterAllocation.RegisterALUByte());
//allocation.allocate(symbols.getVariable("$4"), new RegisterAllocation.RegisterAByte());
*/
// Registers for postinc.kc
/*
allocation.allocate(symbols.getVariable("c#0"), RegisterAllocation.getRegisterA());
allocation.allocate(symbols.getVariable("c#1"), RegisterAllocation.getRegisterA());
allocation.allocate(symbols.getVariable("c#2"), RegisterAllocation.getRegisterA());
allocation.allocate(symbols.getVariable("b#0"), new RegisterAllocation.RegisterZpByte(102));
allocation.allocate(symbols.getVariable("b#1"), new RegisterAllocation.RegisterZpByte(102));
allocation.allocate(symbols.getVariable("b#2"), new RegisterAllocation.RegisterZpByte(102));
allocation.allocate(symbols.getVariable("$1"), new RegisterAllocation.RegisterZpByte(101));
allocation.allocate(symbols.getVariable("a#0"), new RegisterAllocation.RegisterZpByte(103));
allocation.allocate(symbols.getVariable("a#1"), new RegisterAllocation.RegisterZpByte(103));
allocation.allocate(symbols.getVariable("a#2"), new RegisterAllocation.RegisterZpByte(103));
allocation.allocate(symbols.getVariable("$0"), RegisterAllocation.getRegisterA());
allocation.allocate(symbols.getVariable("i#0"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("i#1"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("i#2"), RegisterAllocation.getRegisterX());
*/
// Optimal Registers for flipper-rex2.kc
allocation.allocate(symbols.getVariable("plot::i#0"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("plot::i#1"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("plot::i#2"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("plot::i#3"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("plot::i#4"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("plot::x#0"), RegisterAllocation.getRegisterY());
allocation.allocate(symbols.getVariable("plot::x#1"), RegisterAllocation.getRegisterY());
allocation.allocate(symbols.getVariable("plot::x#2"), RegisterAllocation.getRegisterY());
allocation.allocate(symbols.getVariable("plot::y#0"), new RegisterAllocation.RegisterZpByte(100));
allocation.allocate(symbols.getVariable("plot::y#1"), new RegisterAllocation.RegisterZpByte(100));
allocation.allocate(symbols.getVariable("plot::y#2"), new RegisterAllocation.RegisterZpByte(100));
allocation.allocate(symbols.getVariable("plot::y#3"), new RegisterAllocation.RegisterZpByte(100));
allocation.allocate(symbols.getVariable("plot::y#4"), new RegisterAllocation.RegisterZpByte(100));
allocation.allocate(symbols.getVariable("plot::line#0"), new RegisterAllocation.RegisterZpPointerByte(101));
allocation.allocate(symbols.getVariable("plot::line#1"), new RegisterAllocation.RegisterZpPointerByte(101));
allocation.allocate(symbols.getVariable("plot::line#2"), new RegisterAllocation.RegisterZpPointerByte(101));
allocation.allocate(symbols.getVariable("plot::line#3"), new RegisterAllocation.RegisterZpPointerByte(101));
allocation.allocate(symbols.getVariable("plot::line#4"), new RegisterAllocation.RegisterZpPointerByte(101));
allocation.allocate(symbols.getVariable("plot::$3"), RegisterAllocation.getRegisterA());
allocation.allocate(symbols.getVariable("prepare::i#0"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("prepare::i#1"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("prepare::i#2"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("flip::srcIdx#0"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("flip::srcIdx#0"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("flip::srcIdx#1"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("flip::srcIdx#2"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("flip::srcIdx#3"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("flip::srcIdx#4"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("flip::dstIdx#0"), RegisterAllocation.getRegisterY());
allocation.allocate(symbols.getVariable("flip::dstIdx#1"), RegisterAllocation.getRegisterY());
allocation.allocate(symbols.getVariable("flip::dstIdx#2"), RegisterAllocation.getRegisterY());
allocation.allocate(symbols.getVariable("flip::dstIdx#3"), RegisterAllocation.getRegisterY());
allocation.allocate(symbols.getVariable("flip::dstIdx#4"), RegisterAllocation.getRegisterY());
allocation.allocate(symbols.getVariable("flip::dstIdx#5"), RegisterAllocation.getRegisterY());
allocation.allocate(symbols.getVariable("flip::c#0"), new RegisterAllocation.RegisterZpByte(103));
allocation.allocate(symbols.getVariable("flip::c#1"), new RegisterAllocation.RegisterZpByte(103));
allocation.allocate(symbols.getVariable("flip::c#2"), new RegisterAllocation.RegisterZpByte(103));
allocation.allocate(symbols.getVariable("flip::r#0"), new RegisterAllocation.RegisterZpByte(104));
allocation.allocate(symbols.getVariable("flip::r#1"), new RegisterAllocation.RegisterZpByte(104));
allocation.allocate(symbols.getVariable("flip::r#2"), new RegisterAllocation.RegisterZpByte(104));
allocation.allocate(symbols.getVariable("flip::r#3"), new RegisterAllocation.RegisterZpByte(104));
allocation.allocate(symbols.getVariable("flip::r#4"), new RegisterAllocation.RegisterZpByte(104));
allocation.allocate(symbols.getVariable("flip::i#0"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("flip::i#1"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("flip::i#2"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("flip::$0"), RegisterAllocation.getRegisterA());
allocation.allocate(symbols.getVariable("flip::$8"), RegisterAllocation.getRegisterA());
allocation.allocate(symbols.getVariable("flip::$4"), RegisterAllocation.getRegisterA());
allocation.allocate(symbols.getVariable("main::$1"), RegisterAllocation.getRegisterA());
allocation.allocate(symbols.getVariable("main::$3"), RegisterAllocation.getRegisterA());
allocation.allocate(symbols.getVariable("main::c#0"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("main::c#1"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("main::c#2"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("main::c#3"), RegisterAllocation.getRegisterX());
allocation.allocate(symbols.getVariable("main::c#4"), RegisterAllocation.getRegisterX());
symbols.setAllocation(allocation);
}
private void performAllocation(Scope scope, RegisterAllocation allocation) {
for (Symbol symbol : scope.getAllSymbols()) {
if (symbol instanceof Scope) {
performAllocation((Scope) symbol, allocation);
} else if (symbol instanceof VariableIntermediate || symbol instanceof VariableVersion) {
Variable var = (Variable) symbol;
if (symbol.getType().equals(SymbolTypeBasic.BYTE)) {
allocation.allocate(var, new RegisterAllocation.RegisterZpByte(currentZp++));
} else if (symbol.getType().equals(SymbolTypeBasic.WORD)) {
allocation.allocate(var, new RegisterAllocation.RegisterZpWord(currentZp));
currentZp = currentZp + 2;
} else if (symbol.getType().equals(SymbolTypeBasic.BOOLEAN)) {
allocation.allocate(var, new RegisterAllocation.RegisterZpBool(currentZp++));
} else if (symbol.getType().equals(SymbolTypeBasic.VOID)) {
// No need to allocate register for VOID value
} else if (symbol.getType() instanceof SymbolTypePointer) {
allocation.allocate(var, new RegisterAllocation.RegisterZpPointerByte(currentZp));
currentZp = currentZp + 2;
} else {
throw new RuntimeException("Unhandled variable type " + symbol);
}
}
}
}
}

136
src/dk/camelot64/kickc/passes/Pass4RegisterAllocationTrivial.java Normal file
View File

@ -0,0 +1,136 @@
package dk.camelot64.kickc.passes;
import dk.camelot64.kickc.icl.*;
/**
* Register Allocation for variables
*/
public class Pass4RegisterAllocationTrivial {
private ControlFlowGraph graph;
private ProgramScope symbols;
int currentZp = 2;
public Pass4RegisterAllocationTrivial(Program program) {
this.graph = program.getGraph();
this.symbols = program.getScope();
}
public void allocate() {
RegisterAllocation allocation = new RegisterAllocation();
performAllocation(symbols, allocation);
// Register allocation for fibmem.kc
/*
allocation.allocate(new VariableRef("i#1"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("i#2"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("$1"), new RegisterAllocation.RegisterAByte());
allocation.allocate(new VariableRef("$3"), new RegisterAllocation.RegisterALUByte());
//allocation.allocate(new VariableRef("$4"), new RegisterAllocation.RegisterAByte());
*/
// Registers for postinc.kc
/*
allocation.allocate(new VariableRef("c#0"), RegisterAllocation.getRegisterA());
allocation.allocate(new VariableRef("c#1"), RegisterAllocation.getRegisterA());
allocation.allocate(new VariableRef("c#2"), RegisterAllocation.getRegisterA());
allocation.allocate(new VariableRef("b#0"), new RegisterAllocation.RegisterZpByte(102));
allocation.allocate(new VariableRef("b#1"), new RegisterAllocation.RegisterZpByte(102));
allocation.allocate(new VariableRef("b#2"), new RegisterAllocation.RegisterZpByte(102));
allocation.allocate(new VariableRef("$1"), new RegisterAllocation.RegisterZpByte(101));
allocation.allocate(new VariableRef("a#0"), new RegisterAllocation.RegisterZpByte(103));
allocation.allocate(new VariableRef("a#1"), new RegisterAllocation.RegisterZpByte(103));
allocation.allocate(new VariableRef("a#2"), new RegisterAllocation.RegisterZpByte(103));
allocation.allocate(new VariableRef("$0"), RegisterAllocation.getRegisterA());
allocation.allocate(new VariableRef("i#0"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("i#1"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("i#2"), RegisterAllocation.getRegisterX());
*/
// Optimal Registers for flipper-rex2.kc
allocation.allocate(new VariableRef("plot::i#0"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("plot::i#1"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("plot::i#2"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("plot::i#3"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("plot::i#4"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("plot::x#0"), RegisterAllocation.getRegisterY());
allocation.allocate(new VariableRef("plot::x#1"), RegisterAllocation.getRegisterY());
allocation.allocate(new VariableRef("plot::x#2"), RegisterAllocation.getRegisterY());
allocation.allocate(new VariableRef("plot::y#0"), new RegisterAllocation.RegisterZpByte(100));
allocation.allocate(new VariableRef("plot::y#1"), new RegisterAllocation.RegisterZpByte(100));
allocation.allocate(new VariableRef("plot::y#2"), new RegisterAllocation.RegisterZpByte(100));
allocation.allocate(new VariableRef("plot::y#3"), new RegisterAllocation.RegisterZpByte(100));
allocation.allocate(new VariableRef("plot::y#4"), new RegisterAllocation.RegisterZpByte(100));
allocation.allocate(new VariableRef("plot::line#0"), new RegisterAllocation.RegisterZpPointerByte(101));
allocation.allocate(new VariableRef("plot::line#1"), new RegisterAllocation.RegisterZpPointerByte(101));
allocation.allocate(new VariableRef("plot::line#2"), new RegisterAllocation.RegisterZpPointerByte(101));
allocation.allocate(new VariableRef("plot::line#3"), new RegisterAllocation.RegisterZpPointerByte(101));
allocation.allocate(new VariableRef("plot::line#4"), new RegisterAllocation.RegisterZpPointerByte(101));
allocation.allocate(new VariableRef("plot::$3"), RegisterAllocation.getRegisterA());
allocation.allocate(new VariableRef("prepare::i#0"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("prepare::i#1"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("prepare::i#2"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("flip::srcIdx#0"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("flip::srcIdx#0"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("flip::srcIdx#1"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("flip::srcIdx#2"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("flip::srcIdx#3"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("flip::srcIdx#4"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("flip::dstIdx#0"), RegisterAllocation.getRegisterY());
allocation.allocate(new VariableRef("flip::dstIdx#1"), RegisterAllocation.getRegisterY());
allocation.allocate(new VariableRef("flip::dstIdx#2"), RegisterAllocation.getRegisterY());
allocation.allocate(new VariableRef("flip::dstIdx#3"), RegisterAllocation.getRegisterY());
allocation.allocate(new VariableRef("flip::dstIdx#4"), RegisterAllocation.getRegisterY());
allocation.allocate(new VariableRef("flip::dstIdx#5"), RegisterAllocation.getRegisterY());
allocation.allocate(new VariableRef("flip::c#0"), new RegisterAllocation.RegisterZpByte(103));
allocation.allocate(new VariableRef("flip::c#1"), new RegisterAllocation.RegisterZpByte(103));
allocation.allocate(new VariableRef("flip::c#2"), new RegisterAllocation.RegisterZpByte(103));
allocation.allocate(new VariableRef("flip::r#0"), new RegisterAllocation.RegisterZpByte(104));
allocation.allocate(new VariableRef("flip::r#1"), new RegisterAllocation.RegisterZpByte(104));
allocation.allocate(new VariableRef("flip::r#2"), new RegisterAllocation.RegisterZpByte(104));
allocation.allocate(new VariableRef("flip::r#3"), new RegisterAllocation.RegisterZpByte(104));
allocation.allocate(new VariableRef("flip::r#4"), new RegisterAllocation.RegisterZpByte(104));
allocation.allocate(new VariableRef("flip::i#0"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("flip::i#1"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("flip::i#2"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("flip::$0"), RegisterAllocation.getRegisterA());
allocation.allocate(new VariableRef("flip::$8"), RegisterAllocation.getRegisterA());
allocation.allocate(new VariableRef("flip::$4"), RegisterAllocation.getRegisterA());
allocation.allocate(new VariableRef("main::$1"), RegisterAllocation.getRegisterA());
allocation.allocate(new VariableRef("main::$3"), RegisterAllocation.getRegisterA());
allocation.allocate(new VariableRef("main::c#0"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("main::c#1"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("main::c#2"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("main::c#3"), RegisterAllocation.getRegisterX());
allocation.allocate(new VariableRef("main::c#4"), RegisterAllocation.getRegisterX());
symbols.setAllocation(allocation);
}
private void performAllocation(Scope scope, RegisterAllocation allocation) {
for (Symbol symbol : scope.getAllSymbols()) {
if (symbol instanceof Scope) {
performAllocation((Scope) symbol, allocation);
} else if (symbol instanceof VariableIntermediate || symbol instanceof VariableVersion) {
Variable var = (Variable) symbol;
if (symbol.getType().equals(SymbolTypeBasic.BYTE)) {
allocation.allocate(var.getRef(), new RegisterAllocation.RegisterZpByte(currentZp++));
} else if (symbol.getType().equals(SymbolTypeBasic.WORD)) {
allocation.allocate(var.getRef(), new RegisterAllocation.RegisterZpWord(currentZp));
currentZp = currentZp + 2;
} else if (symbol.getType().equals(SymbolTypeBasic.BOOLEAN)) {
allocation.allocate(var.getRef(), new RegisterAllocation.RegisterZpBool(currentZp++));
} else if (symbol.getType().equals(SymbolTypeBasic.VOID)) {
// No need to allocate register for VOID value
} else if (symbol.getType() instanceof SymbolTypePointer) {
allocation.allocate(var.getRef(), new RegisterAllocation.RegisterZpPointerByte(currentZp));
currentZp = currentZp + 2;
} else {
throw new RuntimeException("Unhandled variable type " + symbol);
}
}
}
}
}

202
src/dk/camelot64/kickc/passes/Pass4ZeroPageAllocationLiveRange.java Normal file
View File

@ -0,0 +1,202 @@
package dk.camelot64.kickc.passes;
import dk.camelot64.kickc.CompileLog;
import dk.camelot64.kickc.icl.*;
import java.util.ArrayList;
import java.util.List;
/**
* Zero Page Register Allocation for variables based on live ranges and phi equivalence classes.
*/
public class Pass4ZeroPageAllocationLiveRange {
private Program program;
private CompileLog log;
public Pass4ZeroPageAllocationLiveRange(Program program, CompileLog log) {
this.program = program;
this.log = log;
}
public void allocate() {
// Initial equivalence classes from phi statements
Pass3PhiMemCoalesce.EquivalenceClassPhiInitializer equivalenceClassPhiInitializer = new Pass3PhiMemCoalesce.EquivalenceClassPhiInitializer(program);
equivalenceClassPhiInitializer.visitGraph(program.getGraph());
LiveRangeEquivalenceClassSet liveRangeEquivalenceClassSet = equivalenceClassPhiInitializer.getPhiEquivalenceClasses();
log.append("Initial phi equivalence classes");
for (LiveRangeEquivalenceClass liveRangeEquivalenceClass : liveRangeEquivalenceClassSet.getEquivalenceClasses()) {
log.append(liveRangeEquivalenceClass.toString());
}
// Coalesce over copy assignments
EquivalenceClassCopyCoalescer equivalenceClassCopyCoalescer = new EquivalenceClassCopyCoalescer(liveRangeEquivalenceClassSet);
equivalenceClassCopyCoalescer.visitGraph(program.getGraph());
log.append("Copy Coalesced equivalence classes");
for (LiveRangeEquivalenceClass liveRangeEquivalenceClass : liveRangeEquivalenceClassSet.getEquivalenceClasses()) {
log.append(liveRangeEquivalenceClass.toString());
}
// Add all other variables one by one to an available equivalence class - or create a new one
EquivalenceClassAdder equivalenceClassAdder = new EquivalenceClassAdder(liveRangeEquivalenceClassSet);
equivalenceClassAdder.visitGraph(program.getGraph());
log.append("Complete equivalence classes");
for (LiveRangeEquivalenceClass liveRangeEquivalenceClass : liveRangeEquivalenceClassSet.getEquivalenceClasses()) {
log.append(liveRangeEquivalenceClass.toString());
}
// Allocate zeropage registers to equivalence classes
RegisterAllocation allocation = new RegisterAllocation();
for (LiveRangeEquivalenceClass liveRangeEquivalenceClass : liveRangeEquivalenceClassSet.getEquivalenceClasses()) {
List<VariableRef> variables = liveRangeEquivalenceClass.getVariables();
Variable firstVar = program.getScope().getVariable(variables.get(0));
RegisterAllocation.Register zpRegister = allocateNewRegister(firstVar.getType());
for (VariableRef variable : variables) {
allocation.allocate(variable, zpRegister);
}
log.append("Allocated "+zpRegister+" to "+liveRangeEquivalenceClass);
}
program.getScope().setAllocation(allocation);
}
/** Add all variables to a non-overlapping equivalence or create a new one. */
private class EquivalenceClassAdder extends ControlFlowGraphBaseVisitor<Void> {
private LiveRangeEquivalenceClassSet liveRangeEquivalenceClassSet;
EquivalenceClassAdder(LiveRangeEquivalenceClassSet liveRangeEquivalenceClassSet) {
this.liveRangeEquivalenceClassSet = liveRangeEquivalenceClassSet;
}
@Override
public Void visitAssignment(StatementAssignment assignment) {
if (assignment.getlValue() instanceof VariableRef) {
VariableRef lValVar = (VariableRef) assignment.getlValue();
List<VariableRef> preferences = new ArrayList<>();
addPreference(preferences, assignment.getrValue1());
addPreference(preferences, assignment.getrValue2());
addToEquivalenceClassSet(lValVar, preferences);
}
return null;
}
private void addToEquivalenceClassSet(VariableRef lValVar, List<VariableRef> preferences) {
VariableLiveRanges variableLiveRanges = program.getScope().getLiveRanges();
LiveRangeEquivalenceClass lValEquivalenceClass =
liveRangeEquivalenceClassSet.getEquivalenceClass(lValVar);
if(lValEquivalenceClass==null) {
LiveRange lValLiveRange = variableLiveRanges.getLiveRange(lValVar);
// Variable in need of an equivalence class - Look through preferences
LiveRangeEquivalenceClass chosen = null;
for (VariableRef preference : preferences) {
LiveRangeEquivalenceClass preferenceEquivalenceClass = liveRangeEquivalenceClassSet.getEquivalenceClass(preference);
if (preferenceEquivalenceClass != null) {
Variable potentialVariable = program.getScope().getVariable(preference);
Variable lValVariable = program.getScope().getVariable(lValVar);
if (lValVariable.getType().equals(potentialVariable.getType())) {
if (!lValLiveRange.overlaps(preferenceEquivalenceClass.getLiveRange())) {
chosen = preferenceEquivalenceClass;
chosen.addVariable(lValVar);
break;
}
}
}
}
if (chosen == null) {
// No preference usable - look through all others
for (LiveRangeEquivalenceClass potentialEquivalenceClass : liveRangeEquivalenceClassSet.getEquivalenceClasses()) {
VariableRef potentialVariableRef = potentialEquivalenceClass.getVariables().get(0);
Variable potentialVariable = program.getScope().getVariable(potentialVariableRef);
Variable lValVariable = program.getScope().getVariable(lValVar);
if (lValVariable.getType().equals(potentialVariable.getType())) {
if (!lValLiveRange.overlaps(potentialEquivalenceClass.getLiveRange())) {
chosen = potentialEquivalenceClass;
chosen.addVariable(lValVar);
break;
}
}
}
}
if(chosen==null) {
// No other equivalence class is usable - create a new one
chosen = liveRangeEquivalenceClassSet.getOrCreateEquivalenceClass(lValVar);
}
log.append("Added variable "+lValVar+" to zero page equivalence class "+chosen);
}
}
private void addPreference(List<VariableRef> preferences, RValue rValue) {
if(rValue instanceof VariableRef) {
preferences.add((VariableRef) rValue);
}
}
}
/** Coalesce equivalence classes when they do not overlap based on all copy assignments to variables. */
private class EquivalenceClassCopyCoalescer extends ControlFlowGraphBaseVisitor<Void> {
private LiveRangeEquivalenceClassSet liveRangeEquivalenceClassSet;
EquivalenceClassCopyCoalescer(LiveRangeEquivalenceClassSet liveRangeEquivalenceClassSet) {
this.liveRangeEquivalenceClassSet = liveRangeEquivalenceClassSet;
}
@Override
public Void visitAssignment(StatementAssignment assignment) {
if (assignment.getlValue() instanceof VariableRef) {
LiveRangeEquivalenceClass lValEquivalenceClass =
liveRangeEquivalenceClassSet.getEquivalenceClass((VariableRef) assignment.getlValue());
if (lValEquivalenceClass != null && assignment.getOperator() == null && assignment.getrValue1() == null && assignment.getrValue2() instanceof VariableRef) {
// Found copy assignment to a variable in an equivalence class - attempt to coalesce
VariableRef assignVar = (VariableRef) assignment.getrValue2();
LiveRangeEquivalenceClass assignVarEquivalenceClass = liveRangeEquivalenceClassSet.getOrCreateEquivalenceClass(assignVar);
if (lValEquivalenceClass.equals(assignVarEquivalenceClass)) {
log.append("Coalesced (already) " + assignment+" in "+lValEquivalenceClass);
} else if (!lValEquivalenceClass.getLiveRange().overlaps(assignVarEquivalenceClass.getLiveRange())) {
lValEquivalenceClass.addAll(assignVarEquivalenceClass);
liveRangeEquivalenceClassSet.remove(assignVarEquivalenceClass);
log.append("Coalesced " + assignment+" into "+lValEquivalenceClass);
} else {
log.append("Not coalescing " + assignment);
}
}
}
return null;
}
}
/** The current zero page used to create new registers when needed. */
private int currentZp = 2;
/**
* Create a new register for a specific variable type.
* @param varType The variable type to create a register for.
* The register type created uses one or more zero page locations based on the variable type
* @return The new zeropage register
*/
private RegisterAllocation.Register allocateNewRegister(SymbolType varType) {
if (varType.equals(SymbolTypeBasic.BYTE)) {
return new RegisterAllocation.RegisterZpByte(currentZp++);
} else if (varType.equals(SymbolTypeBasic.WORD)) {
RegisterAllocation.RegisterZpWord registerZpWord =
new RegisterAllocation.RegisterZpWord(currentZp);
currentZp = currentZp + 2;
return registerZpWord;
} else if (varType.equals(SymbolTypeBasic.BOOLEAN)) {
return new RegisterAllocation.RegisterZpBool(currentZp++);
} else if (varType.equals(SymbolTypeBasic.VOID)) {
// No need to allocate register for VOID value
return null;
} else if (varType instanceof SymbolTypePointer) {
RegisterAllocation.RegisterZpPointerByte registerZpPointerByte =
new RegisterAllocation.RegisterZpPointerByte(currentZp);
currentZp = currentZp + 2;
return registerZpPointerByte;
} else {
throw new RuntimeException("Unhandled variable type " + varType);
}
}
}

78
src/dk/camelot64/kickc/test/ref/bresenham.asm
View File

@ -1,43 +1,26 @@
BBEGIN:
B1_from_BBEGIN:
lda #0
sta 14
sta 6
lda #12
sta 13
sta 5
lda #0
sta 12
sta 4
lda #<1024
sta 10
sta 2
lda #>1024
sta 10+1
jmp B1
sta 2+1
B1_from_B3:
lda 18
sta 14
lda 17
sta 13
lda 2
sta 12
lda 15
sta 10
lda 15+1
sta 10+1
B1:
ldy #0
lda #81
sta (10),y
lda 12
clc
adc #1
sta 2
lda 10
clc
adc #1
sta 3
lda 10+1
adc #0
sta 3+1
lda 13
sta (2),y
inc 4
inc 2
bne !+
inc 2+1
!:
lda 5
clc
adc #24
sta 5
@ -45,42 +28,23 @@ B1:
cmp 5
bcc B2
B3_from_B1:
lda 14
sta 18
lda 5
sta 17
lda 3
sta 15
lda 3+1
sta 15+1
B3:
lda 2
lda 4
cmp #40
bcc B1_from_B3
BEND:
B2:
lda 14
inc 6
lda 2
clc
adc #1
sta 6
lda #40
clc
adc 3
sta 7
lda #0
adc 3+1
sta 7+1
adc #40
sta 2
bcc !+
inc 2+1
!:
lda 5
sec
sbc #39
sta 9
sta 5
B3_from_B2:
lda 6
sta 18
lda 9
sta 17
lda 7
sta 15
lda 7+1
sta 15+1
jmp B3

446
src/dk/camelot64/kickc/test/ref/bresenham.log
View File

@ -985,60 +985,63 @@ CONTROL FLOW GRAPH - PHI MEM COALESCED
[10] (byte) e#2 ← (byte) e#1 - (byte) 39 [ x#1 cursor#2 e#2 y#1 ]
to:@3
Initial phi equivalence classes
[ cursor#3 cursor#5 cursor#1 cursor#2 ]
[ x#2 x#1 ]
[ e#3 e#5 e#1 e#2 ]
[ y#2 y#4 y#1 ]
Copy Coalesced equivalence classes
[ cursor#3 cursor#5 cursor#1 cursor#2 ]
[ x#2 x#1 ]
[ e#3 e#5 e#1 e#2 ]
[ y#2 y#4 y#1 ]
Complete equivalence classes
[ cursor#3 cursor#5 cursor#1 cursor#2 ]
[ x#2 x#1 ]
[ e#3 e#5 e#1 e#2 ]
[ y#2 y#4 y#1 ]
Allocated zp ptr byte:2 to [ cursor#3 cursor#5 cursor#1 cursor#2 ]
Allocated zp byte:4 to [ x#2 x#1 ]
Allocated zp byte:5 to [ e#3 e#5 e#1 e#2 ]
Allocated zp byte:6 to [ y#2 y#4 y#1 ]
INITIAL ASM
BBEGIN:
B1_from_BBEGIN:
// (byte) y#2 = (byte) 0 // zpby1=coby1
lda #0
sta 14
sta 6
// (byte) e#3 = (byte) 12 // zpby1=coby1
lda #12
sta 13
sta 5
// (byte) x#2 = (byte) 0 // zpby1=coby1
lda #0
sta 12
sta 4
// (byte*) cursor#3 = (word) 1024 // zpptrby1=cowo1
lda #<1024
sta 10
sta 2
lda #>1024
sta 10+1
sta 2+1
jmp B1
B1_from_B3:
// (byte) y#2 = (byte) y#4 // zpby1=zpby2
lda 18
sta 14
// (byte) e#3 = (byte) e#5 // zpby1=zpby2
lda 17
sta 13
// (byte) x#2 = (byte) x#1 // zpby1=zpby2
lda 2
sta 12
// (byte*) cursor#3 = (byte*) cursor#5 // zpptrby1=zpptrby2
lda 15
sta 10
lda 15+1
sta 10+1
// (byte) y#2 = (byte) y#4 // register copy
// (byte) e#3 = (byte) e#5 // register copy
// (byte) x#2 = (byte) x#1 // register copy
// (byte*) cursor#3 = (byte*) cursor#5 // register copy
jmp B1
B1:
// [1] *((byte*) cursor#3) ← (byte) 81 [ cursor#3 x#2 e#3 y#2 ] // zpiby1=coby1
ldy #0
lda #81
sta (10),y
// [2] (byte) x#1 ← (byte) x#2 + (byte) 1 [ x#1 cursor#3 e#3 y#2 ] // zpby1=zpby2_plus_1
lda 12
clc
adc #1
sta 2
// [3] (byte*) cursor#1 ← (byte*) cursor#3 + (byte) 1 [ x#1 e#3 cursor#1 y#2 ] // zpptrby1=zpptrby2_plus_1
lda 10
clc
adc #1
sta 3
lda 10+1
adc #0
sta 3+1
// [4] (byte) e#1 ← (byte) e#3 + (byte) 24 [ x#1 e#1 cursor#1 y#2 ] // zpby1=zpby2_plus_coby1
lda 13
sta (2),y
// [2] (byte) x#1 ← (byte) x#2 + (byte) 1 [ x#1 cursor#3 e#3 y#2 ] // zpby1=zpby1_plus_1
inc 4
// [3] (byte*) cursor#1 ← (byte*) cursor#3 + (byte) 1 [ x#1 e#3 cursor#1 y#2 ] // zpptrby1=zpptrby1_plus_1
inc 2
bne !+
inc 2+1
!:
// [4] (byte) e#1 ← (byte) e#3 + (byte) 24 [ x#1 e#1 cursor#1 y#2 ] // zpby1=zpby1_plus_coby1
lda 5
clc
adc #24
sta 5
@ -1047,56 +1050,37 @@ B1:
cmp 5
bcc B2
B3_from_B1:
// (byte) y#4 = (byte) y#2 // zpby1=zpby2
lda 14
sta 18
// (byte) e#5 = (byte) e#1 // zpby1=zpby2
lda 5
sta 17
// (byte*) cursor#5 = (byte*) cursor#1 // zpptrby1=zpptrby2
lda 3
sta 15
lda 3+1
sta 15+1
// (byte) y#4 = (byte) y#2 // register copy
// (byte) e#5 = (byte) e#1 // register copy
// (byte*) cursor#5 = (byte*) cursor#1 // register copy
jmp B3
B3:
// [7] if((byte) x#1<(byte) 40) goto @1 [ cursor#5 x#1 e#5 y#4 ] // zpby1_lt_coby1_then_la1
lda 2
lda 4
cmp #40
bcc B1_from_B3
jmp BEND
BEND:
B2:
// [8] (byte) y#1 ← (byte) y#2 + (byte) 1 [ x#1 e#1 cursor#1 y#1 ] // zpby1=zpby2_plus_1
lda 14
// [8] (byte) y#1 ← (byte) y#2 + (byte) 1 [ x#1 e#1 cursor#1 y#1 ] // zpby1=zpby1_plus_1
inc 6
// [9] (byte*) cursor#2 ← (byte*) cursor#1 + (byte) 40 [ x#1 e#1 cursor#2 y#1 ] // zpptrby1=zpptrby1_plus_coby1
lda 2
clc
adc #1
sta 6
// [9] (byte*) cursor#2 ← (byte*) cursor#1 + (byte) 40 [ x#1 e#1 cursor#2 y#1 ] // zpptrby1=zpptrby2_plus_coby1
lda #40
clc
adc 3
sta 7
lda #0
adc 3+1
sta 7+1
// [10] (byte) e#2 ← (byte) e#1 - (byte) 39 [ x#1 cursor#2 e#2 y#1 ] // zpby1=zpby2_minus_coby1
adc #40
sta 2
bcc !+
inc 2+1
!:
// [10] (byte) e#2 ← (byte) e#1 - (byte) 39 [ x#1 cursor#2 e#2 y#1 ] // zpby1=zpby1_minus_coby1
lda 5
sec
sbc #39
sta 9
sta 5
B3_from_B2:
// (byte) y#4 = (byte) y#1 // zpby1=zpby2
lda 6
sta 18
// (byte) e#5 = (byte) e#2 // zpby1=zpby2
lda 9
sta 17
// (byte*) cursor#5 = (byte*) cursor#2 // zpptrby1=zpptrby2
lda 7
sta 15
lda 7+1
sta 15+1
// (byte) y#4 = (byte) y#1 // register copy
// (byte) e#5 = (byte) e#2 // register copy
// (byte*) cursor#5 = (byte*) cursor#2 // register copy
jmp B3
Removing instruction jmp B1
@ -1108,54 +1092,38 @@ BBEGIN:
B1_from_BBEGIN:
// (byte) y#2 = (byte) 0 // zpby1=coby1
lda #0
sta 14
sta 6
// (byte) e#3 = (byte) 12 // zpby1=coby1
lda #12
sta 13
sta 5
// (byte) x#2 = (byte) 0 // zpby1=coby1
lda #0
sta 12
sta 4
// (byte*) cursor#3 = (word) 1024 // zpptrby1=cowo1
lda #<1024
sta 10
sta 2
lda #>1024
sta 10+1
sta 2+1
jmp B1
B1_from_B3:
// (byte) y#2 = (byte) y#4 // zpby1=zpby2
lda 18
sta 14
// (byte) e#3 = (byte) e#5 // zpby1=zpby2
lda 17
sta 13
// (byte) x#2 = (byte) x#1 // zpby1=zpby2
lda 2
sta 12
// (byte*) cursor#3 = (byte*) cursor#5 // zpptrby1=zpptrby2
lda 15
sta 10
lda 15+1
sta 10+1
// (byte) y#2 = (byte) y#4 // register copy
// (byte) e#3 = (byte) e#5 // register copy
// (byte) x#2 = (byte) x#1 // register copy
// (byte*) cursor#3 = (byte*) cursor#5 // register copy
B1:
// [1] *((byte*) cursor#3) ← (byte) 81 [ cursor#3 x#2 e#3 y#2 ] // zpiby1=coby1
ldy #0
lda #81
sta (10),y
// [2] (byte) x#1 ← (byte) x#2 + (byte) 1 [ x#1 cursor#3 e#3 y#2 ] // zpby1=zpby2_plus_1
lda 12
clc
adc #1
sta 2
// [3] (byte*) cursor#1 ← (byte*) cursor#3 + (byte) 1 [ x#1 e#3 cursor#1 y#2 ] // zpptrby1=zpptrby2_plus_1
lda 10
clc
adc #1
sta 3
lda 10+1
adc #0
sta 3+1
// [4] (byte) e#1 ← (byte) e#3 + (byte) 24 [ x#1 e#1 cursor#1 y#2 ] // zpby1=zpby2_plus_coby1
lda 13
sta (2),y
// [2] (byte) x#1 ← (byte) x#2 + (byte) 1 [ x#1 cursor#3 e#3 y#2 ] // zpby1=zpby1_plus_1
inc 4
// [3] (byte*) cursor#1 ← (byte*) cursor#3 + (byte) 1 [ x#1 e#3 cursor#1 y#2 ] // zpptrby1=zpptrby1_plus_1
inc 2
bne !+
inc 2+1
!:
// [4] (byte) e#1 ← (byte) e#3 + (byte) 24 [ x#1 e#1 cursor#1 y#2 ] // zpby1=zpby1_plus_coby1
lda 5
clc
adc #24
sta 5
@ -1164,54 +1132,112 @@ B1:
cmp 5
bcc B2
B3_from_B1:
// (byte) y#4 = (byte) y#2 // zpby1=zpby2
lda 14
sta 18
// (byte) e#5 = (byte) e#1 // zpby1=zpby2
lda 5
sta 17
// (byte*) cursor#5 = (byte*) cursor#1 // zpptrby1=zpptrby2
lda 3
sta 15
lda 3+1
sta 15+1
// (byte) y#4 = (byte) y#2 // register copy
// (byte) e#5 = (byte) e#1 // register copy
// (byte*) cursor#5 = (byte*) cursor#1 // register copy
B3:
// [7] if((byte) x#1<(byte) 40) goto @1 [ cursor#5 x#1 e#5 y#4 ] // zpby1_lt_coby1_then_la1
lda 2
lda 4
cmp #40
bcc B1_from_B3
BEND:
B2:
// [8] (byte) y#1 ← (byte) y#2 + (byte) 1 [ x#1 e#1 cursor#1 y#1 ] // zpby1=zpby2_plus_1
lda 14
// [8] (byte) y#1 ← (byte) y#2 + (byte) 1 [ x#1 e#1 cursor#1 y#1 ] // zpby1=zpby1_plus_1
inc 6
// [9] (byte*) cursor#2 ← (byte*) cursor#1 + (byte) 40 [ x#1 e#1 cursor#2 y#1 ] // zpptrby1=zpptrby1_plus_coby1
lda 2
clc
adc #1
sta 6
// [9] (byte*) cursor#2 ← (byte*) cursor#1 + (byte) 40 [ x#1 e#1 cursor#2 y#1 ] // zpptrby1=zpptrby2_plus_coby1
lda #40
clc
adc 3
sta 7
lda #0
adc 3+1
sta 7+1
// [10] (byte) e#2 ← (byte) e#1 - (byte) 39 [ x#1 cursor#2 e#2 y#1 ] // zpby1=zpby2_minus_coby1
adc #40
sta 2
bcc !+
inc 2+1
!:
// [10] (byte) e#2 ← (byte) e#1 - (byte) 39 [ x#1 cursor#2 e#2 y#1 ] // zpby1=zpby1_minus_coby1
lda 5
sec
sbc #39
sta 9
sta 5
B3_from_B2:
// (byte) y#4 = (byte) y#1 // zpby1=zpby2
lda 6
sta 18
// (byte) e#5 = (byte) e#2 // zpby1=zpby2
lda 9
sta 17
// (byte*) cursor#5 = (byte*) cursor#2 // zpptrby1=zpptrby2
lda 7
sta 15
lda 7+1
sta 15+1
// (byte) y#4 = (byte) y#1 // register copy
// (byte) e#5 = (byte) e#2 // register copy
// (byte*) cursor#5 = (byte*) cursor#2 // register copy
jmp B3
Removing instruction jmp B1
Succesful ASM optimization Pass5NextJumpElimination
ASSEMBLER
BBEGIN:
B1_from_BBEGIN:
// (byte) y#2 = (byte) 0 // zpby1=coby1
lda #0
sta 6
// (byte) e#3 = (byte) 12 // zpby1=coby1
lda #12
sta 5
// (byte) x#2 = (byte) 0 // zpby1=coby1
lda #0
sta 4
// (byte*) cursor#3 = (word) 1024 // zpptrby1=cowo1
lda #<1024
sta 2
lda #>1024
sta 2+1
B1_from_B3:
// (byte) y#2 = (byte) y#4 // register copy
// (byte) e#3 = (byte) e#5 // register copy
// (byte) x#2 = (byte) x#1 // register copy
// (byte*) cursor#3 = (byte*) cursor#5 // register copy
B1:
// [1] *((byte*) cursor#3) ← (byte) 81 [ cursor#3 x#2 e#3 y#2 ] // zpiby1=coby1
ldy #0
lda #81
sta (2),y
// [2] (byte) x#1 ← (byte) x#2 + (byte) 1 [ x#1 cursor#3 e#3 y#2 ] // zpby1=zpby1_plus_1
inc 4
// [3] (byte*) cursor#1 ← (byte*) cursor#3 + (byte) 1 [ x#1 e#3 cursor#1 y#2 ] // zpptrby1=zpptrby1_plus_1
inc 2
bne !+
inc 2+1
!:
// [4] (byte) e#1 ← (byte) e#3 + (byte) 24 [ x#1 e#1 cursor#1 y#2 ] // zpby1=zpby1_plus_coby1
lda 5
clc
adc #24
sta 5
// [5] if((byte) 39<(byte) e#1) goto @2 [ x#1 e#1 cursor#1 y#2 ] // coby1_lt_zpby1_then_la1
lda #39
cmp 5
bcc B2
B3_from_B1:
// (byte) y#4 = (byte) y#2 // register copy
// (byte) e#5 = (byte) e#1 // register copy
// (byte*) cursor#5 = (byte*) cursor#1 // register copy
B3:
// [7] if((byte) x#1<(byte) 40) goto @1 [ cursor#5 x#1 e#5 y#4 ] // zpby1_lt_coby1_then_la1
lda 4
cmp #40
bcc B1_from_B3
BEND:
B2:
// [8] (byte) y#1 ← (byte) y#2 + (byte) 1 [ x#1 e#1 cursor#1 y#1 ] // zpby1=zpby1_plus_1
inc 6
// [9] (byte*) cursor#2 ← (byte*) cursor#1 + (byte) 40 [ x#1 e#1 cursor#2 y#1 ] // zpptrby1=zpptrby1_plus_coby1
lda 2
clc
adc #40
sta 2
bcc !+
inc 2+1
!:
// [10] (byte) e#2 ← (byte) e#1 - (byte) 39 [ x#1 cursor#2 e#2 y#1 ] // zpby1=zpby1_minus_coby1
lda 5
sec
sbc #39
sta 5
B3_from_B2:
// (byte) y#4 = (byte) y#1 // register copy
// (byte) e#5 = (byte) e#2 // register copy
// (byte*) cursor#5 = (byte*) cursor#2 // register copy
jmp B3
FINAL SYMBOL TABLE
@ -1223,25 +1249,25 @@ FINAL SYMBOL TABLE
(byte[1000]) SCREEN
(byte) STAR
(byte*) cursor
(byte*) cursor#1 zp ptr byte:3
(byte*) cursor#2 zp ptr byte:7
(byte*) cursor#3 zp ptr byte:10
(byte*) cursor#5 zp ptr byte:15
(byte*) cursor#1 zp ptr byte:2
(byte*) cursor#2 zp ptr byte:2
(byte*) cursor#3 zp ptr byte:2
(byte*) cursor#5 zp ptr byte:2
(byte) e
(byte) e#1 zp byte:5
(byte) e#2 zp byte:9
(byte) e#3 zp byte:13
(byte) e#5 zp byte:17
(byte) e#2 zp byte:5
(byte) e#3 zp byte:5
(byte) e#5 zp byte:5
(byte) x
(byte) x#1 zp byte:2
(byte) x#2 zp byte:12
(byte) x#1 zp byte:4
(byte) x#2 zp byte:4
(byte) x0
(byte) x1
(byte) xd
(byte) y
(byte) y#1 zp byte:6
(byte) y#2 zp byte:14
(byte) y#4 zp byte:18
(byte) y#2 zp byte:6
(byte) y#4 zp byte:6
(byte) y0
(byte) y1
(byte) yd
@ -1251,54 +1277,37 @@ BBEGIN:
B1_from_BBEGIN:
// (byte) y#2 = (byte) 0 // zpby1=coby1
lda #0
sta 14
sta 6
// (byte) e#3 = (byte) 12 // zpby1=coby1
lda #12
sta 13
sta 5
// (byte) x#2 = (byte) 0 // zpby1=coby1
lda #0
sta 12
sta 4
// (byte*) cursor#3 = (word) 1024 // zpptrby1=cowo1
lda #<1024
sta 10
sta 2
lda #>1024
sta 10+1
jmp B1
sta 2+1
B1_from_B3:
// (byte) y#2 = (byte) y#4 // zpby1=zpby2
lda 18
sta 14
// (byte) e#3 = (byte) e#5 // zpby1=zpby2
lda 17
sta 13
// (byte) x#2 = (byte) x#1 // zpby1=zpby2
lda 2
sta 12
// (byte*) cursor#3 = (byte*) cursor#5 // zpptrby1=zpptrby2
lda 15
sta 10
lda 15+1
sta 10+1
// (byte) y#2 = (byte) y#4 // register copy
// (byte) e#3 = (byte) e#5 // register copy
// (byte) x#2 = (byte) x#1 // register copy
// (byte*) cursor#3 = (byte*) cursor#5 // register copy
B1:
// [1] *((byte*) cursor#3) ← (byte) 81 [ cursor#3 x#2 e#3 y#2 ] // zpiby1=coby1
ldy #0
lda #81
sta (10),y
// [2] (byte) x#1 ← (byte) x#2 + (byte) 1 [ x#1 cursor#3 e#3 y#2 ] // zpby1=zpby2_plus_1
lda 12
clc
adc #1
sta 2
// [3] (byte*) cursor#1 ← (byte*) cursor#3 + (byte) 1 [ x#1 e#3 cursor#1 y#2 ] // zpptrby1=zpptrby2_plus_1
lda 10
clc
adc #1
sta 3
lda 10+1
adc #0
sta 3+1
// [4] (byte) e#1 ← (byte) e#3 + (byte) 24 [ x#1 e#1 cursor#1 y#2 ] // zpby1=zpby2_plus_coby1
lda 13
sta (2),y
// [2] (byte) x#1 ← (byte) x#2 + (byte) 1 [ x#1 cursor#3 e#3 y#2 ] // zpby1=zpby1_plus_1
inc 4
// [3] (byte*) cursor#1 ← (byte*) cursor#3 + (byte) 1 [ x#1 e#3 cursor#1 y#2 ] // zpptrby1=zpptrby1_plus_1
inc 2
bne !+
inc 2+1
!:
// [4] (byte) e#1 ← (byte) e#3 + (byte) 24 [ x#1 e#1 cursor#1 y#2 ] // zpby1=zpby1_plus_coby1
lda 5
clc
adc #24
sta 5
@ -1307,53 +1316,34 @@ B1:
cmp 5
bcc B2
B3_from_B1:
// (byte) y#4 = (byte) y#2 // zpby1=zpby2
lda 14
sta 18
// (byte) e#5 = (byte) e#1 // zpby1=zpby2
lda 5
sta 17
// (byte*) cursor#5 = (byte*) cursor#1 // zpptrby1=zpptrby2
lda 3
sta 15
lda 3+1
sta 15+1
// (byte) y#4 = (byte) y#2 // register copy
// (byte) e#5 = (byte) e#1 // register copy
// (byte*) cursor#5 = (byte*) cursor#1 // register copy
B3:
// [7] if((byte) x#1<(byte) 40) goto @1 [ cursor#5 x#1 e#5 y#4 ] // zpby1_lt_coby1_then_la1
lda 2
lda 4
cmp #40
bcc B1_from_B3
BEND:
B2:
// [8] (byte) y#1 ← (byte) y#2 + (byte) 1 [ x#1 e#1 cursor#1 y#1 ] // zpby1=zpby2_plus_1
lda 14
// [8] (byte) y#1 ← (byte) y#2 + (byte) 1 [ x#1 e#1 cursor#1 y#1 ] // zpby1=zpby1_plus_1
inc 6
// [9] (byte*) cursor#2 ← (byte*) cursor#1 + (byte) 40 [ x#1 e#1 cursor#2 y#1 ] // zpptrby1=zpptrby1_plus_coby1
lda 2
clc
adc #1
sta 6
// [9] (byte*) cursor#2 ← (byte*) cursor#1 + (byte) 40 [ x#1 e#1 cursor#2 y#1 ] // zpptrby1=zpptrby2_plus_coby1
lda #40
clc
adc 3
sta 7
lda #0
adc 3+1
sta 7+1
// [10] (byte) e#2 ← (byte) e#1 - (byte) 39 [ x#1 cursor#2 e#2 y#1 ] // zpby1=zpby2_minus_coby1
adc #40
sta 2
bcc !+
inc 2+1
!:
// [10] (byte) e#2 ← (byte) e#1 - (byte) 39 [ x#1 cursor#2 e#2 y#1 ] // zpby1=zpby1_minus_coby1
lda 5
sec
sbc #39
sta 9
sta 5
B3_from_B2:
// (byte) y#4 = (byte) y#1 // zpby1=zpby2
lda 6
sta 18
// (byte) e#5 = (byte) e#2 // zpby1=zpby2
lda 9
sta 17
// (byte*) cursor#5 = (byte*) cursor#2 // zpptrby1=zpptrby2
lda 7
sta 15
lda 7+1
sta 15+1
// (byte) y#4 = (byte) y#1 // register copy
// (byte) e#5 = (byte) e#2 // register copy
// (byte*) cursor#5 = (byte*) cursor#2 // register copy
jmp B3

22
src/dk/camelot64/kickc/test/ref/bresenham.sym
View File

@ -6,25 +6,25 @@
(byte[1000]) SCREEN
(byte) STAR
(byte*) cursor
(byte*) cursor#1 zp ptr byte:3
(byte*) cursor#2 zp ptr byte:7
(byte*) cursor#3 zp ptr byte:10
(byte*) cursor#5 zp ptr byte:15
(byte*) cursor#1 zp ptr byte:2
(byte*) cursor#2 zp ptr byte:2
(byte*) cursor#3 zp ptr byte:2
(byte*) cursor#5 zp ptr byte:2
(byte) e
(byte) e#1 zp byte:5
(byte) e#2 zp byte:9
(byte) e#3 zp byte:13
(byte) e#5 zp byte:17
(byte) e#2 zp byte:5
(byte) e#3 zp byte:5
(byte) e#5 zp byte:5
(byte) x
(byte) x#1 zp byte:2
(byte) x#2 zp byte:12
(byte) x#1 zp byte:4
(byte) x#2 zp byte:4
(byte) x0
(byte) x1
(byte) xd
(byte) y
(byte) y#1 zp byte:6
(byte) y#2 zp byte:14
(byte) y#4 zp byte:18
(byte) y#2 zp byte:6
(byte) y#4 zp byte:6
(byte) y0
(byte) y1
(byte) yd

110
src/dk/camelot64/kickc/test/ref/flipper-rex2.asm
View File

@ -4,23 +4,29 @@ BEND:
main:
jsr prepare
main__B3_from_main:
ldx #25
lda #25
sta 2
jmp main__B3
main__B3_from_B11:
ldx #25
lda #25
sta 2
main__B3_from_B3:
main__B3_from_B6:
main__B3:
lda 53266
sta 5
lda 5
cmp #254
bne main__B3_from_B3
main__B4:
lda 53266
sta 5
lda 5
cmp #255
bne main__B4
main__B6:
dex
cpx #0
dec 2
lda 2
bne main__B3_from_B6
main__B7:
jsr flip
@ -33,85 +39,105 @@ main__Breturn:
plot:
plot__B1_from_plot:
lda #16
sta 100
sta 5
lda #<1236
sta 101
sta 3
lda #>1236
sta 101+1
ldx #0
sta 3+1
lda #0
sta 6
plot__B1_from_B3:
plot__B1:
plot__B2_from_B1:
ldy #0
lda #0
sta 7
plot__B2_from_B2:
plot__B2:
lda 4096,x
sta (101),y
inx
iny
cpy #16
ldy 6
lda 4096,y
sta 2
lda 2
ldy 7
sta (3),y
inc 6
inc 7
lda 7
cmp #16
bcc plot__B2_from_B2
plot__B3:
lda 101
lda 3
clc
adc #40
sta 101
sta 3
bcc !+
inc 101+1
inc 3+1
!:
dec 100
lda 100
dec 5
lda 5
bne plot__B1_from_B3
plot__Breturn:
rts
flip:
flip__B1_from_flip:
lda #16
sta 104
ldy #15
ldx #0
sta 8
lda #15
sta 10
lda #0
sta 9
flip__B1_from_B4:
flip__B1:
flip__B2_from_B1:
lda #16
sta 103
sta 11
flip__B2_from_B2:
flip__B2:
lda 4096,x
ldy 9
lda 4096,y
sta 2
lda 2
ldy 10
sta 4352,y
inx
tya
inc 9
lda 10
clc
adc #16
tay
dec 103
lda 103
sta 10
dec 11
lda 11
bne flip__B2_from_B2
flip__B4:
dey
dec 104
lda 104
dec 10
dec 8
lda 8
bne flip__B1_from_B4
flip__B3_from_B4:
ldx #0
lda #0
sta 12
flip__B3_from_B3:
flip__B3:
lda 4352,x
sta 4096,x
inx
cpx #0
ldy 12
lda 4352,y
sta 2
lda 2
ldy 12
sta 4096,y
inc 12
lda 12
bne flip__B3_from_B3
flip__Breturn:
rts
prepare:
prepare__B1_from_prepare:
ldx #0
lda #0
sta 13
prepare__B1_from_B1:
prepare__B1:
txa
sta 4096,x
inx
cpx #0
ldy 13
tya
sta 4096,y
inc 13
lda 13
bne prepare__B1_from_B1
prepare__Breturn:
rts

974
src/dk/camelot64/kickc/test/ref/flipper-rex2.log
View File

File diff suppressed because it is too large Load Diff

62
src/dk/camelot64/kickc/test/ref/flipper-rex2.sym
View File

@ -5,35 +5,35 @@
(byte[256]) buffer1
(byte[256]) buffer2
(void()) flip()
(byte~) flip::$0 reg byte a
(byte~) flip::$4 reg byte a
(byte~) flip::$0 zp byte:2
(byte~) flip::$4 zp byte:2
(label) flip::@1
(label) flip::@2
(label) flip::@3
(label) flip::@4
(label) flip::@return
(byte) flip::c
(byte) flip::c#1 zp byte:103
(byte) flip::c#2 zp byte:103
(byte) flip::c#1 zp byte:11
(byte) flip::c#2 zp byte:11
(byte) flip::dstIdx
(byte) flip::dstIdx#1 reg byte y
(byte) flip::dstIdx#2 reg byte y
(byte) flip::dstIdx#3 reg byte y
(byte) flip::dstIdx#5 reg byte y
(byte) flip::dstIdx#1 zp byte:10
(byte) flip::dstIdx#2 zp byte:10
(byte) flip::dstIdx#3 zp byte:10
(byte) flip::dstIdx#5 zp byte:10
(byte) flip::i
(byte) flip::i#1 reg byte x
(byte) flip::i#2 reg byte x
(byte) flip::i#1 zp byte:12
(byte) flip::i#2 zp byte:12
(byte) flip::r
(byte) flip::r#1 zp byte:104
(byte) flip::r#2 zp byte:104
(byte) flip::r#1 zp byte:8
(byte) flip::r#2 zp byte:8
(byte) flip::srcIdx
(byte) flip::srcIdx#1 reg byte x
(byte) flip::srcIdx#2 reg byte x
(byte) flip::srcIdx#3 reg byte x
(byte) flip::srcIdx#1 zp byte:9
(byte) flip::srcIdx#2 zp byte:9
(byte) flip::srcIdx#3 zp byte:9
(void()) main()
(byte~) main::$1 reg byte a
(byte~) main::$3 reg byte a
(byte~) main::$1 zp byte:5
(byte~) main::$3 zp byte:5
(label) main::@10
(label) main::@11
(label) main::@3
@ -42,33 +42,33 @@
(label) main::@7
(label) main::@return
(byte) main::c
(byte) main::c#1 reg byte x
(byte) main::c#2 reg byte x
(byte) main::c#1 zp byte:2
(byte) main::c#2 zp byte:2
(void()) plot()
(byte~) plot::$3 reg byte a
(byte~) plot::$3 zp byte:2
(label) plot::@1
(label) plot::@2
(label) plot::@3
(label) plot::@return
(byte) plot::i
(byte) plot::i#1 reg byte x
(byte) plot::i#2 reg byte x
(byte) plot::i#3 reg byte x
(byte) plot::i#1 zp byte:6
(byte) plot::i#2 zp byte:6
(byte) plot::i#3 zp byte:6
(byte*) plot::line
(byte*) plot::line#1 zp ptr byte:101
(byte*) plot::line#2 zp ptr byte:101
(byte*) plot::line#1 zp ptr byte:3
(byte*) plot::line#2 zp ptr byte:3
(byte) plot::x
(byte) plot::x#1 reg byte y
(byte) plot::x#2 reg byte y
(byte) plot::x#1 zp byte:7
(byte) plot::x#2 zp byte:7
(byte) plot::y
(byte) plot::y#1 zp byte:100
(byte) plot::y#2 zp byte:100
(byte) plot::y#1 zp byte:5
(byte) plot::y#2 zp byte:5
(void()) prepare()
(label) prepare::@1
(label) prepare::@return
(byte) prepare::i
(byte) prepare::i#1 reg byte x
(byte) prepare::i#2 reg byte x
(byte) prepare::i#1 zp byte:13
(byte) prepare::i#2 zp byte:13

27
src/dk/camelot64/kickc/test/ref/loopmin.asm
View File

@ -1,37 +1,26 @@
BBEGIN:
B1_from_BBEGIN:
lda #0
sta 5
sta 3
lda #10
sta 4
jmp B1
sta 2
B1_from_B3:
lda 6
sta 5
lda 3
sta 4
B1:
lda 4
lda 2
cmp #5
beq !+
bcs B2
!:
B3_from_B1:
lda 5
sta 6
B3:
lda 4
sta 3
dec 3
lda 3
dec 2
lda 2
bne B1_from_B3
BEND:
B2:
lda 5
lda 3
clc
adc 4
sta 2
adc 2
sta 3
B3_from_B2:
lda 2
sta 6
jmp B3

174
src/dk/camelot64/kickc/test/ref/loopmin.log
View File

@ -341,56 +341,57 @@ CONTROL FLOW GRAPH - PHI MEM COALESCED
[5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ]
to:@3
Initial phi equivalence classes
[ i#2 i#1 ]
[ s#2 s#4 s#1 ]
Copy Coalesced equivalence classes
[ i#2 i#1 ]
[ s#2 s#4 s#1 ]
Complete equivalence classes
[ i#2 i#1 ]
[ s#2 s#4 s#1 ]
Allocated zp byte:2 to [ i#2 i#1 ]
Allocated zp byte:3 to [ s#2 s#4 s#1 ]
INITIAL ASM
BBEGIN:
B1_from_BBEGIN:
// (byte) s#2 = (byte) 0 // zpby1=coby1
lda #0
sta 5
sta 3
// (byte) i#2 = (byte) 10 // zpby1=coby1
lda #10
sta 4
sta 2
jmp B1
B1_from_B3:
// (byte) s#2 = (byte) s#4 // zpby1=zpby2
lda 6
sta 5
// (byte) i#2 = (byte) i#1 // zpby1=zpby2
lda 3
sta 4
// (byte) s#2 = (byte) s#4 // register copy
// (byte) i#2 = (byte) i#1 // register copy
jmp B1
B1:
// [1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ] // zpby1_gt_coby1_then_la1
lda 4
lda 2
cmp #5
beq !+
bcs B2
!:
B3_from_B1:
// (byte) s#4 = (byte) s#2 // zpby1=zpby2
lda 5
sta 6
// (byte) s#4 = (byte) s#2 // register copy
jmp B3
B3:
// [3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] // zpby1=_dec_zpby2
lda 4
sta 3
dec 3
// [3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] // zpby1=_dec_zpby1
dec 2
// [4] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] // zpby1_gt_0_then_la1
lda 3
lda 2
bne B1_from_B3
jmp BEND
BEND:
B2:
// [5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] // zpby1=zpby2_plus_zpby3
lda 5
// [5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] // zpby1=zpby1_plus_zpby2
lda 3
clc
adc 4
sta 2
adc 2
sta 3
B3_from_B2:
// (byte) s#4 = (byte) s#1 // zpby1=zpby2
lda 2
sta 6
// (byte) s#4 = (byte) s#1 // register copy
jmp B3
Removing instruction jmp B1
@ -402,48 +403,78 @@ BBEGIN:
B1_from_BBEGIN:
// (byte) s#2 = (byte) 0 // zpby1=coby1
lda #0
sta 5
sta 3
// (byte) i#2 = (byte) 10 // zpby1=coby1
lda #10
sta 4
sta 2
jmp B1
B1_from_B3:
// (byte) s#2 = (byte) s#4 // zpby1=zpby2
lda 6
sta 5
// (byte) i#2 = (byte) i#1 // zpby1=zpby2
lda 3
sta 4
// (byte) s#2 = (byte) s#4 // register copy
// (byte) i#2 = (byte) i#1 // register copy
B1:
// [1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ] // zpby1_gt_coby1_then_la1
lda 4
lda 2
cmp #5
beq !+
bcs B2
!:
B3_from_B1:
// (byte) s#4 = (byte) s#2 // zpby1=zpby2
lda 5
sta 6
// (byte) s#4 = (byte) s#2 // register copy
B3:
// [3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] // zpby1=_dec_zpby2
lda 4
sta 3
dec 3
// [3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] // zpby1=_dec_zpby1
dec 2
// [4] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] // zpby1_gt_0_then_la1
lda 3
lda 2
bne B1_from_B3
BEND:
B2:
// [5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] // zpby1=zpby2_plus_zpby3
lda 5
// [5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] // zpby1=zpby1_plus_zpby2
lda 3
clc
adc 4
sta 2
adc 2
sta 3
B3_from_B2:
// (byte) s#4 = (byte) s#1 // zpby1=zpby2
// (byte) s#4 = (byte) s#1 // register copy
jmp B3
Removing instruction jmp B1
Succesful ASM optimization Pass5NextJumpElimination
ASSEMBLER
BBEGIN:
B1_from_BBEGIN:
// (byte) s#2 = (byte) 0 // zpby1=coby1
lda #0
sta 3
// (byte) i#2 = (byte) 10 // zpby1=coby1
lda #10
sta 2
B1_from_B3:
// (byte) s#2 = (byte) s#4 // register copy
// (byte) i#2 = (byte) i#1 // register copy
B1:
// [1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ] // zpby1_gt_coby1_then_la1
lda 2
sta 6
cmp #5
beq !+
bcs B2
!:
B3_from_B1:
// (byte) s#4 = (byte) s#2 // register copy
B3:
// [3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] // zpby1=_dec_zpby1
dec 2
// [4] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] // zpby1_gt_0_then_la1
lda 2
bne B1_from_B3
BEND:
B2:
// [5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] // zpby1=zpby1_plus_zpby2
lda 3
clc
adc 2
sta 3
B3_from_B2:
// (byte) s#4 = (byte) s#1 // register copy
jmp B3
FINAL SYMBOL TABLE
@ -453,59 +484,48 @@ FINAL SYMBOL TABLE
(label) @BEGIN
(label) @END
(byte) i
(byte) i#1 zp byte:3
(byte) i#2 zp byte:4
(byte) i#1 zp byte:2
(byte) i#2 zp byte:2
(byte) s
(byte) s#1 zp byte:2
(byte) s#2 zp byte:5
(byte) s#4 zp byte:6
(byte) s#1 zp byte:3
(byte) s#2 zp byte:3
(byte) s#4 zp byte:3
FINAL CODE
BBEGIN:
B1_from_BBEGIN:
// (byte) s#2 = (byte) 0 // zpby1=coby1
lda #0
sta 5
sta 3
// (byte) i#2 = (byte) 10 // zpby1=coby1
lda #10
sta 4
jmp B1
sta 2
B1_from_B3:
// (byte) s#2 = (byte) s#4 // zpby1=zpby2
lda 6
sta 5
// (byte) i#2 = (byte) i#1 // zpby1=zpby2
lda 3
sta 4
// (byte) s#2 = (byte) s#4 // register copy
// (byte) i#2 = (byte) i#1 // register copy
B1:
// [1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ] // zpby1_gt_coby1_then_la1
lda 4
lda 2
cmp #5
beq !+
bcs B2
!:
B3_from_B1:
// (byte) s#4 = (byte) s#2 // zpby1=zpby2
lda 5
sta 6
// (byte) s#4 = (byte) s#2 // register copy
B3:
// [3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] // zpby1=_dec_zpby2
lda 4
sta 3
dec 3
// [3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] // zpby1=_dec_zpby1
dec 2
// [4] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] // zpby1_gt_0_then_la1
lda 3
lda 2
bne B1_from_B3
BEND:
B2:
// [5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] // zpby1=zpby2_plus_zpby3
lda 5
// [5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] // zpby1=zpby1_plus_zpby2
lda 3
clc
adc 4
sta 2
adc 2
sta 3
B3_from_B2:
// (byte) s#4 = (byte) s#1 // zpby1=zpby2
lda 2
sta 6
// (byte) s#4 = (byte) s#1 // register copy
jmp B3

10
src/dk/camelot64/kickc/test/ref/loopmin.sym
View File

@ -4,9 +4,9 @@
(label) @BEGIN
(label) @END
(byte) i
(byte) i#1 zp byte:3
(byte) i#2 zp byte:4
(byte) i#1 zp byte:2
(byte) i#2 zp byte:2
(byte) s
(byte) s#1 zp byte:2
(byte) s#2 zp byte:5
(byte) s#4 zp byte:6
(byte) s#1 zp byte:3
(byte) s#2 zp byte:3
(byte) s#4 zp byte:3

20
src/dk/camelot64/kickc/test/ref/minus.asm
View File

@ -1,28 +1,22 @@
BBEGIN:
B1_from_BBEGIN:
lda #5
sta 5
jmp B1
sta 2
B1_from_B1:
lda 4
sta 5
B1:
lda #2
clc
adc 5
sta 2
lda 2
adc 2
sta 3
lda 3
clc
adc #2
sta 3
lda 3
ldy 5
ldy 2
sta 4352,y
lda 5
clc
adc #1
sta 4
lda 4
inc 2
lda 2
cmp #10
bcc B1_from_B1
BEND:

126
src/dk/camelot64/kickc/test/ref/minus.log
View File

@ -263,40 +263,46 @@ CONTROL FLOW GRAPH - PHI MEM COALESCED
to:@END
@END: from @1
Initial phi equivalence classes
[ i#2 i#1 ]
Copy Coalesced equivalence classes
[ i#2 i#1 ]
Added variable $0 to zero page equivalence class [ $0 ]
Added variable $1 to zero page equivalence class [ $0 $1 ]
Complete equivalence classes
[ i#2 i#1 ]
[ $0 $1 ]
Allocated zp byte:2 to [ i#2 i#1 ]
Allocated zp byte:3 to [ $0 $1 ]
INITIAL ASM
BBEGIN:
B1_from_BBEGIN:
// (byte) i#2 = (byte) 5 // zpby1=coby1
lda #5
sta 5
sta 2
jmp B1
B1_from_B1:
// (byte) i#2 = (byte) i#1 // zpby1=zpby2
lda 4
sta 5
// (byte) i#2 = (byte) i#1 // register copy
jmp B1
B1:
// [1] (byte~) $0 ← (byte) 2 + (byte) i#2 [ i#2 $0 ] // zpby1=coby1_plus_zpby2
lda #2
clc
adc 5
sta 2
// [2] (byte~) $1 ← (byte~) $0 + (byte) 2 [ i#2 $1 ] // zpby1=zpby2_plus_coby1
lda 2
adc 2
sta 3
// [2] (byte~) $1 ← (byte~) $0 + (byte) 2 [ i#2 $1 ] // zpby1=zpby1_plus_coby1
lda 3
clc
adc #2
sta 3
// [3] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] // ptr_cowo1_zpby1=zpby2
lda 3
ldy 5
ldy 2
sta 4352,y
// [4] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] // zpby1=zpby2_plus_1
lda 5
clc
adc #1
sta 4
// [4] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] // zpby1=zpby1_plus_1
inc 2
// [5] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] // zpby1_lt_coby1_then_la1
lda 4
lda 2
cmp #10
bcc B1_from_B1
jmp BEND
@ -310,47 +316,75 @@ BBEGIN:
B1_from_BBEGIN:
// (byte) i#2 = (byte) 5 // zpby1=coby1
lda #5
sta 5
sta 2
jmp B1
B1_from_B1:
// (byte) i#2 = (byte) i#1 // zpby1=zpby2
lda 4
sta 5
// (byte) i#2 = (byte) i#1 // register copy
B1:
// [1] (byte~) $0 ← (byte) 2 + (byte) i#2 [ i#2 $0 ] // zpby1=coby1_plus_zpby2
lda #2
clc
adc 5
sta 2
// [2] (byte~) $1 ← (byte~) $0 + (byte) 2 [ i#2 $1 ] // zpby1=zpby2_plus_coby1
lda 2
adc 2
sta 3
// [2] (byte~) $1 ← (byte~) $0 + (byte) 2 [ i#2 $1 ] // zpby1=zpby1_plus_coby1
lda 3
clc
adc #2
sta 3
// [3] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] // ptr_cowo1_zpby1=zpby2
lda 3
ldy 5
ldy 2
sta 4352,y
// [4] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] // zpby1=zpby2_plus_1
lda 5
clc
adc #1
sta 4
// [4] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] // zpby1=zpby1_plus_1
inc 2
// [5] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] // zpby1_lt_coby1_then_la1
lda 4
lda 2
cmp #10
bcc B1_from_B1
BEND:
Removing instruction jmp B1
Succesful ASM optimization Pass5NextJumpElimination
ASSEMBLER
BBEGIN:
B1_from_BBEGIN:
// (byte) i#2 = (byte) 5 // zpby1=coby1
lda #5
sta 2
B1_from_B1:
// (byte) i#2 = (byte) i#1 // register copy
B1:
// [1] (byte~) $0 ← (byte) 2 + (byte) i#2 [ i#2 $0 ] // zpby1=coby1_plus_zpby2
lda #2
clc
adc 2
sta 3
// [2] (byte~) $1 ← (byte~) $0 + (byte) 2 [ i#2 $1 ] // zpby1=zpby1_plus_coby1
lda 3
clc
adc #2
sta 3
// [3] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] // ptr_cowo1_zpby1=zpby2
lda 3
ldy 2
sta 4352,y
// [4] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] // zpby1=zpby1_plus_1
inc 2
// [5] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] // zpby1_lt_coby1_then_la1
lda 2
cmp #10
bcc B1_from_B1
BEND:
FINAL SYMBOL TABLE
(byte~) $0 zp byte:2
(byte~) $0 zp byte:3
(byte~) $1 zp byte:3
(label) @1
(label) @BEGIN
(label) @END
(byte) i
(byte) i#1 zp byte:4
(byte) i#2 zp byte:5
(byte) i#1 zp byte:2
(byte) i#2 zp byte:2
(byte[16]) p
FINAL CODE
@ -358,34 +392,28 @@ BBEGIN:
B1_from_BBEGIN:
// (byte) i#2 = (byte) 5 // zpby1=coby1
lda #5
sta 5
jmp B1
sta 2
B1_from_B1:
// (byte) i#2 = (byte) i#1 // zpby1=zpby2
lda 4
sta 5
// (byte) i#2 = (byte) i#1 // register copy
B1:
// [1] (byte~) $0 ← (byte) 2 + (byte) i#2 [ i#2 $0 ] // zpby1=coby1_plus_zpby2
lda #2
clc
adc 5
sta 2
// [2] (byte~) $1 ← (byte~) $0 + (byte) 2 [ i#2 $1 ] // zpby1=zpby2_plus_coby1
lda 2
adc 2
sta 3
// [2] (byte~) $1 ← (byte~) $0 + (byte) 2 [ i#2 $1 ] // zpby1=zpby1_plus_coby1
lda 3
clc
adc #2
sta 3
// [3] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] // ptr_cowo1_zpby1=zpby2
lda 3
ldy 5
ldy 2
sta 4352,y
// [4] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] // zpby1=zpby2_plus_1
lda 5
clc
adc #1
sta 4
// [4] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] // zpby1=zpby1_plus_1
inc 2
// [5] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] // zpby1_lt_coby1_then_la1
lda 4
lda 2
cmp #10
bcc B1_from_B1
BEND:

6
src/dk/camelot64/kickc/test/ref/minus.sym
View File

@ -1,9 +1,9 @@
(byte~) $0 zp byte:2
(byte~) $0 zp byte:3
(byte~) $1 zp byte:3
(label) @1
(label) @BEGIN
(label) @END
(byte) i
(byte) i#1 zp byte:4
(byte) i#2 zp byte:5
(byte) i#1 zp byte:2
(byte) i#2 zp byte:2
(byte[16]) p

2
src/dk/camelot64/kickc/test/ref/summin.asm
View File

@ -17,6 +17,6 @@ sum:
lda 2
clc
adc 3
sta 4
sta 2
sum__Breturn:
rts

26
src/dk/camelot64/kickc/test/ref/summin.log
View File

@ -298,6 +298,18 @@ sum::@return: from sum
[4] return (byte) s1#0 [ ]
to:@RETURN
Initial phi equivalence classes
[ sum::a#2 ]
[ sum::b#2 ]
Copy Coalesced equivalence classes
[ sum::a#2 ]
[ sum::b#2 ]
Added variable s1#0 to zero page equivalence class [ sum::a#2 s1#0 ]
Complete equivalence classes
[ sum::a#2 s1#0 ]
[ sum::b#2 ]
Allocated zp byte:2 to [ sum::a#2 s1#0 ]
Allocated zp byte:3 to [ sum::b#2 ]
INITIAL ASM
BBEGIN:
sum_from_BBEGIN:
@ -321,11 +333,11 @@ sum_from_B2:
jmp BEND
BEND:
sum:
// [3] (byte) s1#0 ← (byte) sum::a#2 + (byte) sum::b#2 [ s1#0 ] // zpby1=zpby2_plus_zpby3
// [3] (byte) s1#0 ← (byte) sum::a#2 + (byte) sum::b#2 [ s1#0 ] // zpby1=zpby1_plus_zpby2
lda 2
clc
adc 3
sta 4
sta 2
jmp sum__Breturn
sum__Breturn:
rts
@ -355,11 +367,11 @@ sum_from_B2:
jsr sum
BEND:
sum:
// [3] (byte) s1#0 ← (byte) sum::a#2 + (byte) sum::b#2 [ s1#0 ] // zpby1=zpby2_plus_zpby3
// [3] (byte) s1#0 ← (byte) sum::a#2 + (byte) sum::b#2 [ s1#0 ] // zpby1=zpby1_plus_zpby2
lda 2
clc
adc 3
sta 4
sta 2
sum__Breturn:
rts
@ -368,7 +380,7 @@ FINAL SYMBOL TABLE
(label) @BEGIN
(label) @END
(byte) s1
(byte) s1#0 zp byte:4
(byte) s1#0 zp byte:2
(byte) s2
(byte()) sum((byte) sum::a , (byte) sum::b)
(label) sum::@return
@ -400,11 +412,11 @@ sum_from_B2:
jsr sum
BEND:
sum:
// [3] (byte) s1#0 ← (byte) sum::a#2 + (byte) sum::b#2 [ s1#0 ] // zpby1=zpby2_plus_zpby3
// [3] (byte) s1#0 ← (byte) sum::a#2 + (byte) sum::b#2 [ s1#0 ] // zpby1=zpby1_plus_zpby2
lda 2
clc
adc 3
sta 4
sta 2
sum__Breturn:
rts

2
src/dk/camelot64/kickc/test/ref/summin.sym
View File

@ -2,7 +2,7 @@
(label) @BEGIN
(label) @END
(byte) s1
(byte) s1#0 zp byte:4
(byte) s1#0 zp byte:2
(byte) s2
(byte()) sum((byte) sum::a , (byte) sum::b)
(label) sum::@return