6502/kickc
1
0
Fork 0
mirror of https://gitlab.com/camelot/kickc.git synced 2024-12-19 15:29:48 +00:00
Code Issues Projects Releases Wiki Activity

Added constant addition consolidation optimization.

Browse Source
This commit is contained in:
Jesper Gravgaard 2017-10-15 17:53:18 +02:00
parent 525ac454cc
commit 7b9e80aaac
45 changed files with 4311 additions and 3671 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/main/java/dk/camelot64/kickc/Compiler.java
View File

@ -141,7 +141,7 @@ public class Compiler {
optimizations.add(new Pass2SelfPhiElimination(program));
optimizations.add(new Pass2ConditionalJumpSimplification(program));
optimizations.add(new Pass2ConstantIdentification(program));
optimizations.add(new Pass2ConstantAdditionElimination(program));
pass2OptimizeSSA(program, optimizations);
// Constant inlining optimizations - as the last step to ensure that constant identification has been completed
@ -149,9 +149,6 @@ public class Compiler {
constantOptimizations.add(new Pass2ConstantInlining(program));
pass2OptimizeSSA(program, constantOptimizations);
//optimizations.add(new Pass2ConstantPropagation(program));
//optimizations.add(new Pass2ConstantAdditionElimination(program));
}
private void pass2OptimizeSSA(Program program, List<Pass2SsaOptimization> optimizations) {
@ -160,12 +157,15 @@ public class Compiler {
pass2AssertSSA(program);
ssaOptimized = false;
for (Pass2SsaOptimization optimization : optimizations) {
boolean stepOptimized = optimization.optimize();
if (stepOptimized) {
program.getLog().append("Succesful SSA optimization " + optimization.getClass().getSimpleName() + "");
ssaOptimized = true;
program.getLog().append("CONTROL FLOW GRAPH");
program.getLog().append(program.getGraph().toString(program));
boolean stepOptimized = true;
while (stepOptimized) {
stepOptimized = optimization.optimize();
if (stepOptimized) {
program.getLog().append("Succesful SSA optimization " + optimization.getClass().getSimpleName() + "");
ssaOptimized = true;
program.getLog().append("CONTROL FLOW GRAPH");
program.getLog().append(program.getGraph().toString(program));
}
}
}
}

2
src/main/java/dk/camelot64/kickc/icl/Registers.java
View File

@ -1,7 +1,5 @@
package dk.camelot64.kickc.icl;
import sun.jvm.hotspot.asm.Register;
/** The different registers available for a program */
public class Registers {

103
src/main/java/dk/camelot64/kickc/passes/Pass2ConstantAdditionElimination.java
View File

@ -61,21 +61,21 @@ public class Pass2ConstantAdditionElimination extends Pass2SsaOptimization {
private boolean optimizePointerDereferenceIndexed(StatementAssignment assignment) {
PointerDereferenceIndexed pointerDereferenceIndexed = (PointerDereferenceIndexed) assignment.getlValue();
if(pointerDereferenceIndexed.getPointer() instanceof ConstantInteger && pointerDereferenceIndexed.getIndex() instanceof Constant) {
ConstantInteger ptrConstant = (ConstantInteger) pointerDereferenceIndexed.getPointer();
ConstantInteger idxConstant = (ConstantInteger) pointerDereferenceIndexed.getIndex();
int newPtr = ptrConstant.getNumber() + idxConstant.getNumber();
assignment.setlValue(new PointerDereferenceSimple(new ConstantInteger(newPtr)));
if(pointerDereferenceIndexed.getPointer() instanceof Constant && pointerDereferenceIndexed.getIndex() instanceof Constant) {
Constant ptrConstant = (Constant) pointerDereferenceIndexed.getPointer();
Constant idxConstant = (Constant) pointerDereferenceIndexed.getIndex();
Constant newPtr = new ConstantBinary(ptrConstant, new Operator("+"), idxConstant);
assignment.setlValue(new PointerDereferenceSimple(newPtr));
getLog().append("Consolidated assigned array index constant in assignment " + assignment.getlValue());
return true;
}
if(pointerDereferenceIndexed.getPointer() instanceof ConstantInteger && pointerDereferenceIndexed.getIndex() instanceof VariableRef) {
if(pointerDereferenceIndexed.getPointer() instanceof Constant && pointerDereferenceIndexed.getIndex() instanceof VariableRef) {
VariableRef variable = (VariableRef) pointerDereferenceIndexed.getIndex();
ConstantInteger consolidated = consolidateSubConstants(variable);
Constant consolidated = consolidateSubConstants(variable);
if (consolidated != null) {
ConstantInteger ptrConstant = (ConstantInteger) pointerDereferenceIndexed.getPointer();
int newPtr = ptrConstant.getNumber() + consolidated.getNumber();
pointerDereferenceIndexed.setPointer(new ConstantInteger(newPtr));
Constant ptrConstant = (Constant) pointerDereferenceIndexed.getPointer();
Constant newPtr = new ConstantBinary(ptrConstant, new Operator("+"), consolidated);
pointerDereferenceIndexed.setPointer(newPtr);
getLog().append("Consolidated assigned array index constant in assignment " + assignment.getlValue());
return true;
}
@ -84,23 +84,23 @@ public class Pass2ConstantAdditionElimination extends Pass2SsaOptimization {
}
private boolean optimizeArrayDeref(StatementAssignment assignment) {
if (assignment.getrValue1() instanceof ConstantInteger && assignment.getrValue2() instanceof ConstantInteger) {
ConstantInteger ptrConstant = (ConstantInteger) assignment.getrValue1();
ConstantInteger idxConstant = (ConstantInteger) assignment.getrValue2();
int newPtr = ptrConstant.getNumber() + idxConstant.getNumber();
if (assignment.getrValue1() instanceof Constant && assignment.getrValue2() instanceof Constant) {
Constant ptrConstant = (Constant) assignment.getrValue1();
Constant idxConstant = (Constant) assignment.getrValue2();
Constant newPtr = new ConstantBinary(ptrConstant, new Operator("+"), idxConstant);
assignment.setrValue1(null);
assignment.setOperator(new Operator("*"));
assignment.setrValue2(new ConstantInteger(newPtr));
assignment.setrValue2(newPtr);
getLog().append("Consolidated referenced array index constant in assignment " + assignment.getlValue());
return true;
}
if (assignment.getrValue1() instanceof ConstantInteger && assignment.getrValue2() instanceof VariableRef) {
if (assignment.getrValue1() instanceof Constant && assignment.getrValue2() instanceof VariableRef) {
VariableRef variable = (VariableRef) assignment.getrValue2();
ConstantInteger consolidated = consolidateSubConstants(variable);
Constant consolidated = consolidateSubConstants(variable);
if (consolidated != null) {
ConstantInteger ptrConstant = (ConstantInteger) assignment.getrValue1();
int newPtr = ptrConstant.getNumber() + consolidated.getNumber();
assignment.setrValue1(new ConstantInteger(newPtr));
Constant ptrConstant = (Constant) assignment.getrValue1();
Constant newPtr = new ConstantBinary(ptrConstant, new Operator("+"), consolidated);
assignment.setrValue1(newPtr);
getLog().append("Consolidated referenced array index constant in assignment " + assignment.getlValue());
return true;
}
@ -109,27 +109,23 @@ public class Pass2ConstantAdditionElimination extends Pass2SsaOptimization {
}
private boolean optimizePlus(StatementAssignment assignment) {
if (assignment.getrValue1() instanceof ConstantInteger && assignment.getrValue2() instanceof VariableRef) {
if (assignment.getrValue1() instanceof Constant && assignment.getrValue2() instanceof VariableRef) {
VariableRef variable = (VariableRef) assignment.getrValue2();
ConstantInteger consolidated = consolidateSubConstants(variable);
Constant consolidated = consolidateSubConstants(variable);
if (consolidated != null) {
ConstantInteger const1 = (ConstantInteger) assignment.getrValue1();
assignment.setrValue1(new ConstantInteger(const1.getNumber() + consolidated.getNumber()));
Constant const1 = (Constant) assignment.getrValue1();
assignment.setrValue1(new ConstantBinary(const1, new Operator("+"), consolidated));
getLog().append("Consolidated constant in assignment " + assignment.getlValue());
return true;
}
} else if (assignment.getrValue1() instanceof VariableRef && assignment.getrValue2() instanceof ConstantInteger) {
} else if (assignment.getrValue1() instanceof VariableRef && assignment.getrValue2() instanceof Constant) {
VariableRef variable = (VariableRef) assignment.getrValue1();
ConstantInteger consolidated = consolidateSubConstants(variable);
Constant consolidated = consolidateSubConstants(variable);
if (consolidated != null) {
ConstantInteger const2 = (ConstantInteger) assignment.getrValue2();
int newNumber = const2.getNumber() + consolidated.getNumber();
if (newNumber < 0) {
assignment.setrValue2(new ConstantInteger(-newNumber));
assignment.setOperator(new Operator("-"));
} else {
assignment.setrValue2(new ConstantInteger(newNumber));
}
Constant const2 = (Constant) assignment.getrValue2();
Constant newNumber = new ConstantBinary(consolidated, new Operator("+"), const2);
assignment.setrValue2(newNumber);
// Handling of negative consolidated numbers?
getLog().append("Consolidated constant in assignment " + assignment.getlValue());
return true;
}
@ -141,41 +137,40 @@ public class Pass2ConstantAdditionElimination extends Pass2SsaOptimization {
* Gather up constants from sub addition expressions of a variable, remove them there, and return the aggregated sum.
*
* @param variable The variable to examine
* @return The consolidated constant. Null if no sub-constants were found.
* @return The consolidated constant. Null if no sub-constants were found, or if the constants cannot be consolidated.
*/
private ConstantInteger consolidateSubConstants(VariableRef variable) {
private Constant consolidateSubConstants(VariableRef variable) {
if(getUsages(variable) >1) {
getLog().append("Multiple usages for variable. Not optimizing sub-constant "+variable.toString(getProgram()));
return null;
}
Variable var = getSymbols().getVariable(variable);
StatementAssignment assignment = getGraph().getAssignment(variable);
if (assignment != null && assignment.getOperator() != null && "+".equals(assignment.getOperator().getOperator())) {
if (assignment.getrValue1() instanceof ConstantInteger) {
ConstantInteger constant = (ConstantInteger) assignment.getrValue1();
if (assignment.getrValue1() instanceof Constant) {
Constant constant = (Constant) assignment.getrValue1();
assignment.setrValue1(null);
assignment.setOperator(null);
return constant;
} else if (assignment.getrValue2() instanceof ConstantInteger) {
ConstantInteger constant = (ConstantInteger) assignment.getrValue2();
} else if (assignment.getrValue2() instanceof Constant) {
Constant constant = (Constant) assignment.getrValue2();
assignment.setrValue2(assignment.getrValue1());
assignment.setOperator(null);
assignment.setrValue1(null);
return constant;
} else {
ConstantInteger const1 = null;
Constant const1 = null;
if (assignment.getrValue1() instanceof VariableRef) {
const1 = consolidateSubConstants((VariableRef) assignment.getrValue1());
}
ConstantInteger const2 = null;
Constant const2 = null;
if (assignment.getrValue2() instanceof VariableRef) {
const2 = consolidateSubConstants((VariableRef) assignment.getrValue2());
}
ConstantInteger result = null;
Constant result = null;
if (const1 != null) {
result = const1;
if (const2 != null) {
result = new ConstantInteger(const1.getNumber() + const2.getNumber());
result = new ConstantBinary(const1, new Operator("+"), const2);
}
} else if (const2 != null) {
result = const2;
@ -184,30 +179,30 @@ public class Pass2ConstantAdditionElimination extends Pass2SsaOptimization {
}
}
if (assignment != null && assignment.getOperator() != null && "-".equals(assignment.getOperator().getOperator())) {
if (assignment.getrValue1() instanceof ConstantInteger) {
ConstantInteger constant = (ConstantInteger) assignment.getrValue1();
if (assignment.getrValue1() instanceof Constant) {
Constant constant = (Constant) assignment.getrValue1();
assignment.setrValue1(null);
return constant;
} else if (assignment.getrValue2() instanceof ConstantInteger) {
ConstantInteger constant = (ConstantInteger) assignment.getrValue2();
} else if (assignment.getrValue2() instanceof Constant) {
Constant constant = (Constant) assignment.getrValue2();
assignment.setrValue2(assignment.getrValue1());
assignment.setOperator(null);
assignment.setrValue1(null);
return new ConstantInteger(-constant.getNumber());
return new ConstantUnary(new Operator("-"), constant);
} else {
ConstantInteger const1 = null;
Constant const1 = null;
if (assignment.getrValue1() instanceof VariableRef) {
const1 = consolidateSubConstants((VariableRef) assignment.getrValue1());
}
ConstantInteger const2 = null;
Constant const2 = null;
if (assignment.getrValue2() instanceof VariableRef) {
const2 = consolidateSubConstants((VariableRef) assignment.getrValue2());
}
ConstantInteger result = null;
Constant result = null;
if (const1 != null) {
result = const1;
if (const2 != null) {
result = new ConstantInteger(const1.getNumber() - const2.getNumber());
result = new ConstantBinary(const1, new Operator("-"),const2);
}
} else if (const2 != null) {
result = const2;

2
src/main/java/dk/camelot64/kickc/passes/Pass2ConstantIdentification.java
View File

@ -33,7 +33,7 @@ public class Pass2ConstantIdentification extends Pass2SsaOptimization {
constScope.remove(variable);
constScope.add(constantVar);
constAliases.put(constRef, constantVar.getRef());
getLog().append("Constant " + constantVar.toString(getProgram()));
getLog().append("Constant " + constantVar.toString(getProgram()) + " = "+constantVar.getValue());
}
// Remove assignments to constants in the code
removeAssignments(constants.keySet());

155
src/main/java/dk/camelot64/kickc/test/ref/bresenham.log
View File

@ -936,12 +936,12 @@ main::@return: scope:[main] from main::@2
to:@return
@end: scope:[] from @begin
Constant (const byte) STAR#0
Constant (const byte[1000]) SCREEN#0
Constant (const byte) main::x#0
Constant (const byte) main::y#0
Constant (const byte) main::x1#0
Constant (const byte) main::y1#0
Constant (const byte) STAR#0 = 81
Constant (const byte[1000]) SCREEN#0 = 1024
Constant (const byte) main::x#0 = 0
Constant (const byte) main::y#0 = 0
Constant (const byte) main::x1#0 = 39
Constant (const byte) main::y1#0 = 24
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
@ -987,98 +987,11 @@ main::@return: scope:[main] from main::@2
to:@return
@end: scope:[] from @begin
Alias (byte) main::yd#0 = (byte) main::yd#1
Alias (byte) main::xd#0 = (byte) main::xd#1
Succesful SSA optimization Pass2AliasElimination
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
to:@end
main: scope:[main] from @begin
(byte) main::xd#0 ← (const byte) main::x1#0 - (const byte) main::x#0
(byte) main::yd#0 ← (const byte) main::y1#0 - (const byte) main::y#0
(byte) main::e#0 ← (byte) main::yd#0 / (byte) 2
(byte~) main::$3 ← (const byte) main::y#0 * (byte) 40
(byte*~) main::$4 ← (const byte[1000]) SCREEN#0 + (byte~) main::$3
(byte*) main::cursor#0 ← (byte*~) main::$4 + (const byte) main::x#0
to:main::@1
main::@1: scope:[main] from main main::@2
(byte) main::y#2 ← phi( main/(const byte) main::y#0 main::@2/(byte) main::y#4 )
(byte) main::x1#2 ← phi( main/(const byte) main::x1#0 )
(byte) main::e#3 ← phi( main/(byte) main::e#0 main::@2/(byte) main::e#5 )
(byte) main::x#2 ← phi( main/(const byte) main::x#0 main::@2/(byte) main::x#1 )
(byte*) main::cursor#3 ← phi( main/(byte*) main::cursor#0 main::@2/(byte*) main::cursor#5 )
(byte) STAR#1 ← phi( main/(const byte) STAR#0 )
*((byte*) main::cursor#3) ← (byte) STAR#1
(byte) main::x#1 ← (byte) main::x#2 + (byte) 1
(byte*) main::cursor#1 ← (byte*) main::cursor#3 + (byte) 1
(byte) main::e#1 ← (byte) main::e#3 + (byte) main::yd#0
if((byte) main::xd#0>=(byte) main::e#1) goto main::@2
to:main::@3
main::@2: scope:[main] from main::@1 main::@3
(byte) main::y#4 ← phi( main::@1/(byte) main::y#2 main::@3/(byte) main::y#1 )
(byte) main::e#5 ← phi( main::@1/(byte) main::e#1 main::@3/(byte) main::e#2 )
(byte*) main::cursor#5 ← phi( main::@1/(byte*) main::cursor#1 main::@3/(byte*) main::cursor#2 )
(byte~) main::$14 ← (byte) main::x1#2 + (byte) 1
if((byte) main::x#1<(byte~) main::$14) goto main::@1
to:main::@return
main::@3: scope:[main] from main::@1
(byte) main::y#1 ← (byte) main::y#2 + (byte) 1
(byte*) main::cursor#2 ← (byte*) main::cursor#1 + (byte) 40
(byte) main::e#2 ← (byte) main::e#1 - (byte) main::xd#0
to:main::@2
main::@return: scope:[main] from main::@2
return
to:@return
@end: scope:[] from @begin
Redundant Phi (byte) STAR#1 (const byte) STAR#0
Redundant Phi (byte) main::x1#2 (const byte) main::x1#0
Succesful SSA optimization Pass2RedundantPhiElimination
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
to:@end
main: scope:[main] from @begin
(byte) main::xd#0 ← (const byte) main::x1#0 - (const byte) main::x#0
(byte) main::yd#0 ← (const byte) main::y1#0 - (const byte) main::y#0
(byte) main::e#0 ← (byte) main::yd#0 / (byte) 2
(byte~) main::$3 ← (const byte) main::y#0 * (byte) 40
(byte*~) main::$4 ← (const byte[1000]) SCREEN#0 + (byte~) main::$3
(byte*) main::cursor#0 ← (byte*~) main::$4 + (const byte) main::x#0
to:main::@1
main::@1: scope:[main] from main main::@2
(byte) main::y#2 ← phi( main/(const byte) main::y#0 main::@2/(byte) main::y#4 )
(byte) main::e#3 ← phi( main/(byte) main::e#0 main::@2/(byte) main::e#5 )
(byte) main::x#2 ← phi( main/(const byte) main::x#0 main::@2/(byte) main::x#1 )
(byte*) main::cursor#3 ← phi( main/(byte*) main::cursor#0 main::@2/(byte*) main::cursor#5 )
*((byte*) main::cursor#3) ← (const byte) STAR#0
(byte) main::x#1 ← (byte) main::x#2 + (byte) 1
(byte*) main::cursor#1 ← (byte*) main::cursor#3 + (byte) 1
(byte) main::e#1 ← (byte) main::e#3 + (byte) main::yd#0
if((byte) main::xd#0>=(byte) main::e#1) goto main::@2
to:main::@3
main::@2: scope:[main] from main::@1 main::@3
(byte) main::y#4 ← phi( main::@1/(byte) main::y#2 main::@3/(byte) main::y#1 )
(byte) main::e#5 ← phi( main::@1/(byte) main::e#1 main::@3/(byte) main::e#2 )
(byte*) main::cursor#5 ← phi( main::@1/(byte*) main::cursor#1 main::@3/(byte*) main::cursor#2 )
(byte~) main::$14 ← (const byte) main::x1#0 + (byte) 1
if((byte) main::x#1<(byte~) main::$14) goto main::@1
to:main::@return
main::@3: scope:[main] from main::@1
(byte) main::y#1 ← (byte) main::y#2 + (byte) 1
(byte*) main::cursor#2 ← (byte*) main::cursor#1 + (byte) 40
(byte) main::e#2 ← (byte) main::e#1 - (byte) main::xd#0
to:main::@2
main::@return: scope:[main] from main::@2
return
to:@return
@end: scope:[] from @begin
Constant (const byte) main::xd#0
Constant (const byte) main::yd#0
Constant (const byte) main::$3
Constant (const byte) main::$14
Constant (const byte) main::xd#0 = main::x1#0-main::x#0
Constant (const byte) main::yd#0 = main::y1#0-main::y#0
Constant (const byte) main::$3 = main::y#0*40
Constant (const byte) STAR#1 = STAR#0
Constant (const byte) main::x1#2 = main::x1#0
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
@ -1091,33 +1004,39 @@ main: scope:[main] from @begin
to:main::@1
main::@1: scope:[main] from main main::@2
(byte) main::y#2 ← phi( main/(const byte) main::y#0 main::@2/(byte) main::y#4 )
(byte) main::xd#1 ← phi( main/(const byte) main::xd#0 )
(byte) main::yd#1 ← phi( main/(const byte) main::yd#0 )
(byte) main::e#3 ← phi( main/(byte) main::e#0 main::@2/(byte) main::e#5 )
(byte) main::x#2 ← phi( main/(const byte) main::x#0 main::@2/(byte) main::x#1 )
(byte*) main::cursor#3 ← phi( main/(byte*) main::cursor#0 main::@2/(byte*) main::cursor#5 )
*((byte*) main::cursor#3) ← (const byte) STAR#0
*((byte*) main::cursor#3) ← (const byte) STAR#1
(byte) main::x#1 ← (byte) main::x#2 + (byte) 1
(byte*) main::cursor#1 ← (byte*) main::cursor#3 + (byte) 1
(byte) main::e#1 ← (byte) main::e#3 + (const byte) main::yd#0
if((const byte) main::xd#0>=(byte) main::e#1) goto main::@2
(byte) main::e#1 ← (byte) main::e#3 + (byte) main::yd#1
if((byte) main::xd#1>=(byte) main::e#1) goto main::@2
to:main::@3
main::@2: scope:[main] from main::@1 main::@3
(byte) main::y#4 ← phi( main::@1/(byte) main::y#2 main::@3/(byte) main::y#1 )
(byte) main::e#5 ← phi( main::@1/(byte) main::e#1 main::@3/(byte) main::e#2 )
(byte*) main::cursor#5 ← phi( main::@1/(byte*) main::cursor#1 main::@3/(byte*) main::cursor#2 )
if((byte) main::x#1<(const byte) main::$14) goto main::@1
(byte~) main::$14 ← (const byte) main::x1#2 + (byte) 1
if((byte) main::x#1<(byte~) main::$14) goto main::@1
to:main::@return
main::@3: scope:[main] from main::@1
(byte) main::y#1 ← (byte) main::y#2 + (byte) 1
(byte*) main::cursor#2 ← (byte*) main::cursor#1 + (byte) 40
(byte) main::e#2 ← (byte) main::e#1 - (const byte) main::xd#0
(byte) main::e#2 ← (byte) main::e#1 - (byte) main::xd#1
to:main::@2
main::@return: scope:[main] from main::@2
return
to:@return
@end: scope:[] from @begin
Constant (const byte) main::e#0
Constant (const byte*) main::$4
Constant (const byte) main::e#0 = main::yd#0/2
Constant (const byte*) main::$4 = SCREEN#0+main::$3
Constant (const byte) main::yd#1 = main::yd#0
Constant (const byte) main::xd#1 = main::xd#0
Constant (const byte) main::$14 = main::x1#2+1
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
@ -1131,11 +1050,11 @@ main::@1: scope:[main] from main main::@2
(byte) main::e#3 ← phi( main/(const byte) main::e#0 main::@2/(byte) main::e#5 )
(byte) main::x#2 ← phi( main/(const byte) main::x#0 main::@2/(byte) main::x#1 )
(byte*) main::cursor#3 ← phi( main/(byte*) main::cursor#0 main::@2/(byte*) main::cursor#5 )
*((byte*) main::cursor#3) ← (const byte) STAR#0
*((byte*) main::cursor#3) ← (const byte) STAR#1
(byte) main::x#1 ← (byte) main::x#2 + (byte) 1
(byte*) main::cursor#1 ← (byte*) main::cursor#3 + (byte) 1
(byte) main::e#1 ← (byte) main::e#3 + (const byte) main::yd#0
if((const byte) main::xd#0>=(byte) main::e#1) goto main::@2
(byte) main::e#1 ← (byte) main::e#3 + (const byte) main::yd#1
if((const byte) main::xd#1>=(byte) main::e#1) goto main::@2
to:main::@3
main::@2: scope:[main] from main::@1 main::@3
(byte) main::y#4 ← phi( main::@1/(byte) main::y#2 main::@3/(byte) main::y#1 )
@ -1146,14 +1065,14 @@ main::@2: scope:[main] from main::@1 main::@3
main::@3: scope:[main] from main::@1
(byte) main::y#1 ← (byte) main::y#2 + (byte) 1
(byte*) main::cursor#2 ← (byte*) main::cursor#1 + (byte) 40
(byte) main::e#2 ← (byte) main::e#1 - (const byte) main::xd#0
(byte) main::e#2 ← (byte) main::e#1 - (const byte) main::xd#1
to:main::@2
main::@return: scope:[main] from main::@2
return
to:@return
@end: scope:[] from @begin
Constant (const byte*) main::cursor#0
Constant (const byte*) main::cursor#0 = main::$4+main::x#0
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
@ -1166,11 +1085,11 @@ main::@1: scope:[main] from main main::@2
(byte) main::e#3 ← phi( main/(const byte) main::e#0 main::@2/(byte) main::e#5 )
(byte) main::x#2 ← phi( main/(const byte) main::x#0 main::@2/(byte) main::x#1 )
(byte*) main::cursor#3 ← phi( main/(const byte*) main::cursor#0 main::@2/(byte*) main::cursor#5 )
*((byte*) main::cursor#3) ← (const byte) STAR#0
*((byte*) main::cursor#3) ← (const byte) STAR#1
(byte) main::x#1 ← (byte) main::x#2 + (byte) 1
(byte*) main::cursor#1 ← (byte*) main::cursor#3 + (byte) 1
(byte) main::e#1 ← (byte) main::e#3 + (const byte) main::yd#0
if((const byte) main::xd#0>=(byte) main::e#1) goto main::@2
(byte) main::e#1 ← (byte) main::e#3 + (const byte) main::yd#1
if((const byte) main::xd#1>=(byte) main::e#1) goto main::@2
to:main::@3
main::@2: scope:[main] from main::@1 main::@3
(byte) main::y#4 ← phi( main::@1/(byte) main::y#2 main::@3/(byte) main::y#1 )
@ -1181,20 +1100,28 @@ main::@2: scope:[main] from main::@1 main::@3
main::@3: scope:[main] from main::@1
(byte) main::y#1 ← (byte) main::y#2 + (byte) 1
(byte*) main::cursor#2 ← (byte*) main::cursor#1 + (byte) 40
(byte) main::e#2 ← (byte) main::e#1 - (const byte) main::xd#0
(byte) main::e#2 ← (byte) main::e#1 - (const byte) main::xd#1
to:main::@2
main::@return: scope:[main] from main::@2
return
to:@return
@end: scope:[] from @begin
Multiple usages for variable. Not optimizing sub-constant (byte) main::y#2
Multiple usages for variable. Not optimizing sub-constant (byte*) main::cursor#1
Multiple usages for variable. Not optimizing sub-constant (byte) main::y#2
Multiple usages for variable. Not optimizing sub-constant (byte*) main::cursor#1
Constant inlined main::$3 = (byte) 0*(byte) 40
Constant inlined main::$4 = (const byte[1000]) SCREEN#0+(byte) 0*(byte) 40
Constant inlined main::xd#1 = (const byte) main::xd#0
Constant inlined main::x#0 = (byte) 0
Constant inlined STAR#1 = (const byte) STAR#0
Constant inlined main::x1#2 = (const byte) main::x1#0
Constant inlined main::cursor#0 = (const byte[1000]) SCREEN#0+(byte) 0*(byte) 40+(byte) 0
Constant inlined main::$14 = (const byte) main::x1#0+(byte) 1
Constant inlined main::y#0 = (byte) 0
Constant inlined main::e#0 = (const byte) main::yd#0/(byte) 2
Constant inlined main::yd#1 = (const byte) main::yd#0
Succesful SSA optimization Pass2ConstantInlining
CONTROL FLOW GRAPH
@begin: scope:[] from

135
src/main/java/dk/camelot64/kickc/test/ref/bresenhamarr.log
View File

@ -767,12 +767,12 @@ CONTROL FLOW GRAPH
to:@2
@end: scope:[] from @2
Constant (const byte) STAR#0
Constant (const byte[1000]) screen#0
Constant (const byte) x#0
Constant (const byte) y#0
Constant (const byte) x1#0
Constant (const byte) y1#0
Constant (const byte) STAR#0 = 81
Constant (const byte[1000]) screen#0 = 1024
Constant (const byte) x#0 = 0
Constant (const byte) y#0 = 0
Constant (const byte) x1#0 = 39
Constant (const byte) y1#0 = 24
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
@ -812,86 +812,12 @@ CONTROL FLOW GRAPH
to:@2
@end: scope:[] from @2
Alias (byte) yd#0 = (byte) yd#1
Alias (byte) xd#0 = (byte) xd#1
Succesful SSA optimization Pass2AliasElimination
CONTROL FLOW GRAPH
@begin: scope:[] from
(byte) xd#0 ← (const byte) x1#0 - (const byte) x#0
(byte) yd#0 ← (const byte) y1#0 - (const byte) y#0
(byte) e#0 ← (byte) yd#0 / (byte) 2
(byte~) $3 ← (const byte) y#0 * (byte) 40
(word) idx#0 ← (const byte) x#0 + (byte~) $3
to:@1
@1: scope:[] from @2 @begin
(byte) y#2 ← phi( @2/(byte) y#4 @begin/(const byte) y#0 )
(byte) x1#2 ← phi( @begin/(const byte) x1#0 )
(byte) e#3 ← phi( @2/(byte) e#5 @begin/(byte) e#0 )
(byte) x#2 ← phi( @2/(byte) x#1 @begin/(const byte) x#0 )
(word) idx#3 ← phi( @2/(word) idx#5 @begin/(word) idx#0 )
(byte[1000]) screen#1 ← phi( @begin/(const byte[1000]) screen#0 )
(byte) STAR#1 ← phi( @begin/(const byte) STAR#0 )
*((byte[1000]) screen#1 + (word) idx#3) ← (byte) STAR#1
(byte) x#1 ← (byte) x#2 + (byte) 1
(word) idx#1 ← (word) idx#3 + (byte) 1
(byte) e#1 ← (byte) e#3 + (byte) yd#0
if((byte) xd#0>=(byte) e#1) goto @2
to:@3
@2: scope:[] from @1 @3
(byte) y#4 ← phi( @1/(byte) y#2 @3/(byte) y#1 )
(byte) e#5 ← phi( @1/(byte) e#1 @3/(byte) e#2 )
(word) idx#5 ← phi( @1/(word) idx#1 @3/(word) idx#2 )
(byte~) $13 ← (byte) x1#2 + (byte) 1
if((byte) x#1<(byte~) $13) goto @1
to:@end
@3: scope:[] from @1
(byte) y#1 ← (byte) y#2 + (byte) 1
(word) idx#2 ← (word) idx#1 + (byte) 40
(byte) e#2 ← (byte) e#1 - (byte) xd#0
to:@2
@end: scope:[] from @2
Redundant Phi (byte) STAR#1 (const byte) STAR#0
Redundant Phi (byte[1000]) screen#1 (const byte[1000]) screen#0
Redundant Phi (byte) x1#2 (const byte) x1#0
Succesful SSA optimization Pass2RedundantPhiElimination
CONTROL FLOW GRAPH
@begin: scope:[] from
(byte) xd#0 ← (const byte) x1#0 - (const byte) x#0
(byte) yd#0 ← (const byte) y1#0 - (const byte) y#0
(byte) e#0 ← (byte) yd#0 / (byte) 2
(byte~) $3 ← (const byte) y#0 * (byte) 40
(word) idx#0 ← (const byte) x#0 + (byte~) $3
to:@1
@1: scope:[] from @2 @begin
(byte) y#2 ← phi( @2/(byte) y#4 @begin/(const byte) y#0 )
(byte) e#3 ← phi( @2/(byte) e#5 @begin/(byte) e#0 )
(byte) x#2 ← phi( @2/(byte) x#1 @begin/(const byte) x#0 )
(word) idx#3 ← phi( @2/(word) idx#5 @begin/(word) idx#0 )
*((const byte[1000]) screen#0 + (word) idx#3) ← (const byte) STAR#0
(byte) x#1 ← (byte) x#2 + (byte) 1
(word) idx#1 ← (word) idx#3 + (byte) 1
(byte) e#1 ← (byte) e#3 + (byte) yd#0
if((byte) xd#0>=(byte) e#1) goto @2
to:@3
@2: scope:[] from @1 @3
(byte) y#4 ← phi( @1/(byte) y#2 @3/(byte) y#1 )
(byte) e#5 ← phi( @1/(byte) e#1 @3/(byte) e#2 )
(word) idx#5 ← phi( @1/(word) idx#1 @3/(word) idx#2 )
(byte~) $13 ← (const byte) x1#0 + (byte) 1
if((byte) x#1<(byte~) $13) goto @1
to:@end
@3: scope:[] from @1
(byte) y#1 ← (byte) y#2 + (byte) 1
(word) idx#2 ← (word) idx#1 + (byte) 40
(byte) e#2 ← (byte) e#1 - (byte) xd#0
to:@2
@end: scope:[] from @2
Constant (const byte) xd#0
Constant (const byte) yd#0
Constant (const byte) $3
Constant (const byte) $13
Constant (const byte) xd#0 = x1#0-x#0
Constant (const byte) yd#0 = y1#0-y#0
Constant (const byte) $3 = y#0*40
Constant (const byte) STAR#1 = STAR#0
Constant (const byte[1000]) screen#1 = screen#0
Constant (const byte) x1#2 = x1#0
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
@ -900,30 +826,36 @@ CONTROL FLOW GRAPH
to:@1
@1: scope:[] from @2 @begin
(byte) y#2 ← phi( @2/(byte) y#4 @begin/(const byte) y#0 )
(byte) xd#1 ← phi( @begin/(const byte) xd#0 )
(byte) yd#1 ← phi( @begin/(const byte) yd#0 )
(byte) e#3 ← phi( @2/(byte) e#5 @begin/(byte) e#0 )
(byte) x#2 ← phi( @2/(byte) x#1 @begin/(const byte) x#0 )
(word) idx#3 ← phi( @2/(word) idx#5 @begin/(word) idx#0 )
*((const byte[1000]) screen#0 + (word) idx#3) ← (const byte) STAR#0
*((const byte[1000]) screen#1 + (word) idx#3) ← (const byte) STAR#1
(byte) x#1 ← (byte) x#2 + (byte) 1
(word) idx#1 ← (word) idx#3 + (byte) 1
(byte) e#1 ← (byte) e#3 + (const byte) yd#0
if((const byte) xd#0>=(byte) e#1) goto @2
(byte) e#1 ← (byte) e#3 + (byte) yd#1
if((byte) xd#1>=(byte) e#1) goto @2
to:@3
@2: scope:[] from @1 @3
(byte) y#4 ← phi( @1/(byte) y#2 @3/(byte) y#1 )
(byte) e#5 ← phi( @1/(byte) e#1 @3/(byte) e#2 )
(word) idx#5 ← phi( @1/(word) idx#1 @3/(word) idx#2 )
if((byte) x#1<(const byte) $13) goto @1
(byte~) $13 ← (const byte) x1#2 + (byte) 1
if((byte) x#1<(byte~) $13) goto @1
to:@end
@3: scope:[] from @1
(byte) y#1 ← (byte) y#2 + (byte) 1
(word) idx#2 ← (word) idx#1 + (byte) 40
(byte) e#2 ← (byte) e#1 - (const byte) xd#0
(byte) e#2 ← (byte) e#1 - (byte) xd#1
to:@2
@end: scope:[] from @2
Constant (const byte) e#0
Constant (const word) idx#0
Constant (const byte) e#0 = yd#0/2
Constant (const word) idx#0 = x#0+$3
Constant (const byte) yd#1 = yd#0
Constant (const byte) xd#1 = xd#0
Constant (const byte) $13 = x1#2+1
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
@ -933,11 +865,11 @@ CONTROL FLOW GRAPH
(byte) e#3 ← phi( @2/(byte) e#5 @begin/(const byte) e#0 )
(byte) x#2 ← phi( @2/(byte) x#1 @begin/(const byte) x#0 )
(word) idx#3 ← phi( @2/(word) idx#5 @begin/(const word) idx#0 )
*((const byte[1000]) screen#0 + (word) idx#3) ← (const byte) STAR#0
*((const byte[1000]) screen#1 + (word) idx#3) ← (const byte) STAR#1
(byte) x#1 ← (byte) x#2 + (byte) 1
(word) idx#1 ← (word) idx#3 + (byte) 1
(byte) e#1 ← (byte) e#3 + (const byte) yd#0
if((const byte) xd#0>=(byte) e#1) goto @2
(byte) e#1 ← (byte) e#3 + (const byte) yd#1
if((const byte) xd#1>=(byte) e#1) goto @2
to:@3
@2: scope:[] from @1 @3
(byte) y#4 ← phi( @1/(byte) y#2 @3/(byte) y#1 )
@ -948,14 +880,23 @@ CONTROL FLOW GRAPH
@3: scope:[] from @1
(byte) y#1 ← (byte) y#2 + (byte) 1
(word) idx#2 ← (word) idx#1 + (byte) 40
(byte) e#2 ← (byte) e#1 - (const byte) xd#0
(byte) e#2 ← (byte) e#1 - (const byte) xd#1
to:@2
@end: scope:[] from @2
Multiple usages for variable. Not optimizing sub-constant (byte) y#2
Multiple usages for variable. Not optimizing sub-constant (word) idx#1
Multiple usages for variable. Not optimizing sub-constant (byte) y#2
Multiple usages for variable. Not optimizing sub-constant (word) idx#1
Constant inlined yd#1 = (const byte) yd#0
Constant inlined $13 = (const byte) x1#0+(byte) 1
Constant inlined x1#2 = (const byte) x1#0
Constant inlined e#0 = (const byte) yd#0/(byte) 2
Constant inlined xd#1 = (const byte) xd#0
Constant inlined y#0 = (byte) 0
Constant inlined idx#0 = (byte) 0+(byte) 0*(byte) 40
Constant inlined screen#1 = (const byte[1000]) screen#0
Constant inlined STAR#1 = (const byte) STAR#0
Constant inlined x#0 = (byte) 0
Constant inlined $3 = (byte) 0*(byte) 40
Succesful SSA optimization Pass2ConstantInlining

52
src/main/java/dk/camelot64/kickc/test/ref/constantmin.log
View File

@ -402,12 +402,12 @@ main::@return: scope:[main] from main::@1
to:@return
@end: scope:[] from @begin
Constant (const byte*) SCREEN#0
Constant (const byte) STAR#0
Constant (const byte*) VIC#0
Constant (const byte) $0
Constant (const byte) RED#0
Constant (const byte) main::i#0
Constant (const byte*) SCREEN#0 = 1024
Constant (const byte) STAR#0 = 81
Constant (const byte*) VIC#0 = 53248
Constant (const byte) $0 = 16*2
Constant (const byte) RED#0 = 2
Constant (const byte) main::i#0 = 40
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
@ -433,33 +433,9 @@ main::@return: scope:[main] from main::@1
to:@return
@end: scope:[] from @begin
Redundant Phi (byte) STAR#2 (const byte) STAR#0
Redundant Phi (byte*) SCREEN#2 (const byte*) SCREEN#0
Succesful SSA optimization Pass2RedundantPhiElimination
CONTROL FLOW GRAPH
@begin: scope:[] from
(byte*~) $1 ← (const byte*) VIC#0 + (const byte) $0
(byte*) BGCOL#0 ← (byte*~) $1 + (byte) 1
call main param-assignment
to:@end
main: scope:[main] from @begin
*((const byte*) SCREEN#0) ← (const byte) STAR#0
*((byte*) BGCOL#0) ← (const byte) RED#0
to:main::@1
main::@1: scope:[main] from main main::@1
(byte) main::i#2 ← phi( main/(const byte) main::i#0 main::@1/(byte) main::i#1 )
(byte~) main::$0 ← (const byte) STAR#0 + (byte) 1
*((const byte*) SCREEN#0 + (byte) main::i#2) ← (byte~) main::$0
(byte) main::i#1 ← ++ (byte) main::i#2
if((byte) main::i#1!=(byte) 80) goto main::@1
to:main::@return
main::@return: scope:[main] from main::@1
return
to:@return
@end: scope:[] from @begin
Constant (const byte*) $1
Constant (const byte) main::$0
Constant (const byte*) $1 = VIC#0+$0
Constant (const byte) STAR#2 = STAR#0
Constant (const byte*) SCREEN#2 = SCREEN#0
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
@ -472,7 +448,8 @@ main: scope:[main] from @begin
to:main::@1
main::@1: scope:[main] from main main::@1
(byte) main::i#2 ← phi( main/(const byte) main::i#0 main::@1/(byte) main::i#1 )
*((const byte*) SCREEN#0 + (byte) main::i#2) ← (const byte) main::$0
(byte~) main::$0 ← (const byte) STAR#2 + (byte) 1
*((const byte*) SCREEN#2 + (byte) main::i#2) ← (byte~) main::$0
(byte) main::i#1 ← ++ (byte) main::i#2
if((byte) main::i#1!=(byte) 80) goto main::@1
to:main::@return
@ -481,7 +458,8 @@ main::@return: scope:[main] from main::@1
to:@return
@end: scope:[] from @begin
Constant (const byte*) BGCOL#0
Constant (const byte*) BGCOL#0 = $1+1
Constant (const byte) main::$0 = STAR#2+1
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
@ -493,7 +471,7 @@ main: scope:[main] from @begin
to:main::@1
main::@1: scope:[main] from main main::@1
(byte) main::i#2 ← phi( main/(const byte) main::i#0 main::@1/(byte) main::i#1 )
*((const byte*) SCREEN#0 + (byte) main::i#2) ← (const byte) main::$0
*((const byte*) SCREEN#2 + (byte) main::i#2) ← (const byte) main::$0
(byte) main::i#1 ← ++ (byte) main::i#2
if((byte) main::i#1!=(byte) 80) goto main::@1
to:main::@return
@ -502,6 +480,8 @@ main::@return: scope:[main] from main::@1
to:@return
@end: scope:[] from @begin
Constant inlined SCREEN#2 = (const byte*) SCREEN#0
Constant inlined STAR#2 = (const byte) STAR#0
Constant inlined $1 = (const byte*) VIC#0+(byte) 16*(byte) 2
Constant inlined $0 = (byte) 16*(byte) 2
Constant inlined main::i#0 = (byte) 40

11
src/main/java/dk/camelot64/kickc/test/ref/fibmem.asm
View File

@ -1,15 +1,16 @@
.const fibs = $1100
jsr main
main: {
lda #$0
sta $1100
sta fibs+$0
lda #$1
sta $1101
sta fibs+$1
ldx #$0
b1:
lda $1100,x
lda fibs,x
clc
adc $1101,x
sta $1102,x
adc fibs+$1,x
sta fibs+$2,x
inx
cpx #$f
bcc b1

10
src/main/java/dk/camelot64/kickc/test/ref/fibmem.cfg
View File

@ -3,15 +3,15 @@
to:@end
@end: scope:[] from @begin
main: scope:[main] from @begin
[1] *((word) 4352) ← (byte) 0 [ ]
[2] *((word) 4353) ← (byte) 1 [ ]
[1] *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0 [ ]
[2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ]
to:main::@1
main::@1: scope:[main] from main main::@1
[3] (byte) main::i#2 ← phi( main/(byte) 0 main::@1/(byte) main::i#1 ) [ main::i#2 ]
[4] (byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2 [ main::i#2 main::$1 ]
[5] (byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
[4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ]
[5] (byte~) main::$3 ← (const byte[15]) fibs#0+(byte) 1 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
[6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ]
[7] *((word) 4354 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ]
[7] *((const byte[15]) fibs#0+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ]
[8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ]
[9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ]
to:main::@return

357
src/main/java/dk/camelot64/kickc/test/ref/fibmem.log
View File

@ -250,51 +250,21 @@ main::@return: scope:[main] from main::@1
to:@return
@end: scope:[] from @begin
Constant (byte[15]) fibs#0 (word) 4352
Constant (byte) main::i#0 (byte) 0
Succesful SSA optimization Pass2ConstantPropagation
Alias (byte[15]) fibs#0 = (byte[15]) fibs#1
Succesful SSA optimization Pass2AliasElimination
CONTROL FLOW GRAPH
@begin: scope:[] from
(byte[15]) fibs#0 ← (word) 4352
call main param-assignment
to:@end
main: scope:[main] from @begin
(byte[15]) fibs#1 ← phi( @begin/(word) 4352 )
*((byte[15]) fibs#1 + (byte) 0) ← (byte) 0
*((byte[15]) fibs#1 + (byte) 1) ← (byte) 1
*((byte[15]) fibs#0 + (byte) 0) ← (byte) 0
*((byte[15]) fibs#0 + (byte) 1) ← (byte) 1
(byte) main::i#0 ← (byte) 0
to:main::@1
main::@1: scope:[main] from main main::@1
(byte[15]) fibs#2 ← phi( main/(byte[15]) fibs#1 main::@1/(byte[15]) fibs#2 )
(byte) main::i#2 ← phi( main/(byte) 0 main::@1/(byte) main::i#1 )
(byte~) main::$0 ← (byte) main::i#2 + (byte) 2
(byte~) main::$1 ← (byte[15]) fibs#2 *idx (byte) main::i#2
(byte~) main::$2 ← (byte) main::i#2 + (byte) 1
(byte~) main::$3 ← (byte[15]) fibs#2 *idx (byte~) main::$2
(byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
*((byte[15]) fibs#2 + (byte~) main::$0) ← (byte~) main::$4
(byte) main::i#1 ← ++ (byte) main::i#2
(boolean~) main::$5 ← (byte) main::i#1 < (byte) 15
if((boolean~) main::$5) goto main::@1
to:main::@return
main::@return: scope:[main] from main::@1
return
to:@return
@end: scope:[] 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
Redundant Phi (byte[15]) fibs#1 (word) 4352
Succesful SSA optimization Pass2RedundantPhiElimination
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
to:@end
main: scope:[main] from @begin
*((word) 4352 + (byte) 0) ← (byte) 0
*((word) 4352 + (byte) 1) ← (byte) 1
to:main::@1
main::@1: scope:[main] from main main::@1
(byte[15]) fibs#2 ← phi( main/(word) 4352 main::@1/(byte[15]) fibs#2 )
(byte) main::i#2 ← phi( main/(byte) 0 main::@1/(byte) main::i#1 )
(byte[15]) fibs#2 ← phi( main/(byte[15]) fibs#0 main::@1/(byte[15]) fibs#2 )
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@1/(byte) main::i#1 )
(byte~) main::$0 ← (byte) main::i#2 + (byte) 2
(byte~) main::$1 ← (byte[15]) fibs#2 *idx (byte) main::i#2
(byte~) main::$2 ← (byte) main::i#2 + (byte) 1
@ -314,15 +284,17 @@ Self Phi Eliminated (byte[15]) fibs#2
Succesful SSA optimization Pass2SelfPhiElimination
CONTROL FLOW GRAPH
@begin: scope:[] from
(byte[15]) fibs#0 ← (word) 4352
call main param-assignment
to:@end
main: scope:[main] from @begin
*((word) 4352 + (byte) 0) ← (byte) 0
*((word) 4352 + (byte) 1) ← (byte) 1
*((byte[15]) fibs#0 + (byte) 0) ← (byte) 0
*((byte[15]) fibs#0 + (byte) 1) ← (byte) 1
(byte) main::i#0 ← (byte) 0
to:main::@1
main::@1: scope:[main] from main main::@1
(byte[15]) fibs#2 ← phi( main/(word) 4352 )
(byte) main::i#2 ← phi( main/(byte) 0 main::@1/(byte) main::i#1 )
(byte[15]) fibs#2 ← phi( main/(byte[15]) fibs#0 )
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@1/(byte) main::i#1 )
(byte~) main::$0 ← (byte) main::i#2 + (byte) 2
(byte~) main::$1 ← (byte[15]) fibs#2 *idx (byte) main::i#2
(byte~) main::$2 ← (byte) main::i#2 + (byte) 1
@ -342,15 +314,17 @@ Simple Condition (boolean~) main::$5 if((byte) main::i#1<(byte) 15) goto main::@
Succesful SSA optimization Pass2ConditionalJumpSimplification
CONTROL FLOW GRAPH
@begin: scope:[] from
(byte[15]) fibs#0 ← (word) 4352
call main param-assignment
to:@end
main: scope:[main] from @begin
*((word) 4352 + (byte) 0) ← (byte) 0
*((word) 4352 + (byte) 1) ← (byte) 1
*((byte[15]) fibs#0 + (byte) 0) ← (byte) 0
*((byte[15]) fibs#0 + (byte) 1) ← (byte) 1
(byte) main::i#0 ← (byte) 0
to:main::@1
main::@1: scope:[main] from main main::@1
(byte[15]) fibs#2 ← phi( main/(word) 4352 )
(byte) main::i#2 ← phi( main/(byte) 0 main::@1/(byte) main::i#1 )
(byte[15]) fibs#2 ← phi( main/(byte[15]) fibs#0 )
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@1/(byte) main::i#1 )
(byte~) main::$0 ← (byte) main::i#2 + (byte) 2
(byte~) main::$1 ← (byte[15]) fibs#2 *idx (byte) main::i#2
(byte~) main::$2 ← (byte) main::i#2 + (byte) 1
@ -365,24 +339,26 @@ main::@return: scope:[main] from main::@1
to:@return
@end: scope:[] from @begin
Constant (byte[15]) fibs#2 (word) 4352
Succesful SSA optimization Pass2ConstantPropagation
Constant (const byte[15]) fibs#0 = 4352
Constant (const byte) main::i#0 = 0
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
to:@end
main: scope:[main] from @begin
*((word) 4352 + (byte) 0) ← (byte) 0
*((word) 4352 + (byte) 1) ← (byte) 1
*((const byte[15]) fibs#0 + (byte) 0) ← (byte) 0
*((const byte[15]) fibs#0 + (byte) 1) ← (byte) 1
to:main::@1
main::@1: scope:[main] from main main::@1
(byte) main::i#2 ← phi( main/(byte) 0 main::@1/(byte) main::i#1 )
(byte[15]) fibs#2 ← phi( main/(const byte[15]) fibs#0 )
(byte) main::i#2 ← phi( main/(const byte) main::i#0 main::@1/(byte) main::i#1 )
(byte~) main::$0 ← (byte) main::i#2 + (byte) 2
(byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2
(byte~) main::$1 ← (byte[15]) fibs#2 *idx (byte) main::i#2
(byte~) main::$2 ← (byte) main::i#2 + (byte) 1
(byte~) main::$3 ← (word) 4352 *idx (byte~) main::$2
(byte~) main::$3 ← (byte[15]) fibs#2 *idx (byte~) main::$2
(byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
*((word) 4352 + (byte~) main::$0) ← (byte~) main::$4
*((byte[15]) fibs#2 + (byte~) main::$0) ← (byte~) main::$4
(byte) main::i#1 ← ++ (byte) main::i#2
if((byte) main::i#1<(byte) 15) goto main::@1
to:main::@return
@ -391,30 +367,56 @@ main::@return: scope:[main] from main::@1
to:@return
@end: scope:[] from @begin
Consolidated assigned array index constant in assignment *(4352)
Consolidated assigned array index constant in assignment *(4353)
Constant (const byte[15]) fibs#2 = fibs#0
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
to:@end
main: scope:[main] from @begin
*((const byte[15]) fibs#0 + (byte) 0) ← (byte) 0
*((const byte[15]) fibs#0 + (byte) 1) ← (byte) 1
to:main::@1
main::@1: scope:[main] from main main::@1
(byte) main::i#2 ← phi( main/(const byte) main::i#0 main::@1/(byte) main::i#1 )
(byte~) main::$0 ← (byte) main::i#2 + (byte) 2
(byte~) main::$1 ← (const byte[15]) fibs#2 *idx (byte) main::i#2
(byte~) main::$2 ← (byte) main::i#2 + (byte) 1
(byte~) main::$3 ← (const byte[15]) fibs#2 *idx (byte~) main::$2
(byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
*((const byte[15]) fibs#2 + (byte~) main::$0) ← (byte~) main::$4
(byte) main::i#1 ← ++ (byte) main::i#2
if((byte) main::i#1<(byte) 15) goto main::@1
to:main::@return
main::@return: scope:[main] from main::@1
return
to:@return
@end: scope:[] from @begin
Consolidated assigned array index constant in assignment *(fibs#0+0)
Consolidated assigned array index constant in assignment *(fibs#0+1)
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Consolidated referenced array index constant in assignment main::$3
Consolidated assigned array index constant in assignment *(4354 + main::$0)
Consolidated assigned array index constant in assignment *(fibs#2+2 + main::$0)
Succesful SSA optimization Pass2ConstantAdditionElimination
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
to:@end
main: scope:[main] from @begin
*((word) 4352) ← (byte) 0
*((word) 4353) ← (byte) 1
*((const byte[15]) fibs#0+(byte) 0) ← (byte) 0
*((const byte[15]) fibs#0+(byte) 1) ← (byte) 1
to:main::@1
main::@1: scope:[main] from main main::@1
(byte) main::i#2 ← phi( main/(byte) 0 main::@1/(byte) main::i#1 )
(byte) main::i#2 ← phi( main/(const byte) main::i#0 main::@1/(byte) main::i#1 )
(byte~) main::$0 ← (byte) main::i#2
(byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2
(byte~) main::$1 ← (const byte[15]) fibs#2 *idx (byte) main::i#2
(byte~) main::$2 ← (byte) main::i#2
(byte~) main::$3 ← (word) 4353 *idx (byte~) main::$2
(byte~) main::$3 ← (const byte[15]) fibs#2+(byte) 1 *idx (byte~) main::$2
(byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
*((word) 4354 + (byte~) main::$0) ← (byte~) main::$4
*((const byte[15]) fibs#2+(byte) 2 + (byte~) main::$0) ← (byte~) main::$4
(byte) main::i#1 ← ++ (byte) main::i#2
if((byte) main::i#1<(byte) 15) goto main::@1
to:main::@return
@ -423,6 +425,7 @@ main::@return: scope:[main] from main::@1
to:@return
@end: scope:[] from @begin
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Alias (byte) main::i#2 = (byte~) main::$0 (byte~) main::$2
Succesful SSA optimization Pass2AliasElimination
CONTROL FLOW GRAPH
@ -430,15 +433,15 @@ CONTROL FLOW GRAPH
call main param-assignment
to:@end
main: scope:[main] from @begin
*((word) 4352) ← (byte) 0
*((word) 4353) ← (byte) 1
*((const byte[15]) fibs#0+(byte) 0) ← (byte) 0
*((const byte[15]) fibs#0+(byte) 1) ← (byte) 1
to:main::@1
main::@1: scope:[main] from main main::@1
(byte) main::i#2 ← phi( main/(byte) 0 main::@1/(byte) main::i#1 )
(byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2
(byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2
(byte) main::i#2 ← phi( main/(const byte) main::i#0 main::@1/(byte) main::i#1 )
(byte~) main::$1 ← (const byte[15]) fibs#2 *idx (byte) main::i#2
(byte~) main::$3 ← (const byte[15]) fibs#2+(byte) 1 *idx (byte) main::i#2
(byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
*((word) 4354 + (byte) main::i#2) ← (byte~) main::$4
*((const byte[15]) fibs#2+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4
(byte) main::i#1 ← ++ (byte) main::i#2
if((byte) main::i#1<(byte) 15) goto main::@1
to:main::@return
@ -450,10 +453,39 @@ main::@return: scope:[main] from main::@1
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Constant inlined fibs#2 = (const byte[15]) fibs#0
Constant inlined main::i#0 = (byte) 0
Succesful SSA optimization Pass2ConstantInlining
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
to:@end
main: scope:[main] from @begin
*((const byte[15]) fibs#0+(byte) 0) ← (byte) 0
*((const byte[15]) fibs#0+(byte) 1) ← (byte) 1
to:main::@1
main::@1: scope:[main] from main main::@1
(byte) main::i#2 ← phi( main/(byte) 0 main::@1/(byte) main::i#1 )
(byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2
(byte~) main::$3 ← (const byte[15]) fibs#0+(byte) 1 *idx (byte) main::i#2
(byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
*((const byte[15]) fibs#0+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4
(byte) main::i#1 ← ++ (byte) main::i#2
if((byte) main::i#1<(byte) 15) goto main::@1
to:main::@return
main::@return: scope:[main] from main::@1
return
to:@return
@end: scope:[] from @begin
FINAL SYMBOL TABLE
(label) @begin
(label) @end
(byte[15]) fibs
(const byte[15]) fibs#0 = (word) 4352
(void()) main()
(byte~) main::$1
(byte~) main::$3
@ -473,15 +505,15 @@ CONTROL FLOW GRAPH - PHI LIFTED
to:@end
@end: scope:[] from @begin
main: scope:[main] from @begin
*((word) 4352) ← (byte) 0
*((word) 4353) ← (byte) 1
*((const byte[15]) fibs#0+(byte) 0) ← (byte) 0
*((const byte[15]) fibs#0+(byte) 1) ← (byte) 1
to:main::@1
main::@1: scope:[main] from main main::@3
(byte) main::i#2 ← phi( main/(byte) 0 main::@3/(byte~) main::i#3 )
(byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2
(byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2
(byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2
(byte~) main::$3 ← (const byte[15]) fibs#0+(byte) 1 *idx (byte) main::i#2
(byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
*((word) 4354 + (byte) main::i#2) ← (byte~) main::$4
*((const byte[15]) fibs#0+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4
(byte) main::i#1 ← ++ (byte) main::i#2
if((byte) main::i#1<(byte) 15) goto main::@3
to:main::@return
@ -504,15 +536,15 @@ CONTROL FLOW GRAPH - LIVE RANGES FOUND
to:@end
@end: scope:[] from @begin
main: scope:[main] from @begin
[1] *((word) 4352) ← (byte) 0 [ ]
[2] *((word) 4353) ← (byte) 1 [ ]
[1] *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0 [ ]
[2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ]
to:main::@1
main::@1: scope:[main] from main main::@3
[3] (byte) main::i#2 ← phi( main/(byte) 0 main::@3/(byte~) main::i#3 ) [ main::i#2 ]
[4] (byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2 [ main::i#2 main::$1 ]
[5] (byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
[4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ]
[5] (byte~) main::$3 ← (const byte[15]) fibs#0+(byte) 1 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
[6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ]
[7] *((word) 4354 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ]
[7] *((const byte[15]) fibs#0+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ]
[8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ]
[9] if((byte) main::i#1<(byte) 15) goto main::@3 [ main::i#1 ]
to:main::@return
@ -537,15 +569,15 @@ CONTROL FLOW GRAPH - PHI MEM COALESCED
to:@end
@end: scope:[] from @begin
main: scope:[main] from @begin
[1] *((word) 4352) ← (byte) 0 [ ]
[2] *((word) 4353) ← (byte) 1 [ ]
[1] *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0 [ ]
[2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ]
to:main::@1
main::@1: scope:[main] from main main::@1
[3] (byte) main::i#2 ← phi( main/(byte) 0 main::@1/(byte) main::i#1 ) [ main::i#2 ]
[4] (byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2 [ main::i#2 main::$1 ]
[5] (byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
[4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ]
[5] (byte~) main::$3 ← (const byte[15]) fibs#0+(byte) 1 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
[6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ]
[7] *((word) 4354 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ]
[7] *((const byte[15]) fibs#0+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ]
[8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ]
[9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ]
to:main::@return
@ -597,7 +629,8 @@ Allocated zp ZP_BYTE:3 [ main::$1 ]
Allocated zp ZP_BYTE:4 [ main::$3 ]
Allocated zp ZP_BYTE:5 [ main::$4 ]
INITIAL ASM
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const fibs = $1100
//SEG1 @begin
bbegin:
//SEG2 [0] call main param-assignment [ ]
@ -611,12 +644,12 @@ main: {
.label _3 = 4
.label _4 = 5
.label i = 2
//SEG5 [1] *((word) 4352) ← (byte) 0 [ ] -- _star_cowo1=coby2
//SEG5 [1] *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0 [ ] -- _star_cowo1=coby2
lda #$0
sta $1100
//SEG6 [2] *((word) 4353) ← (byte) 1 [ ] -- _star_cowo1=coby2
sta fibs+$0
//SEG6 [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] -- _star_cowo1=coby2
lda #$1
sta $1101
sta fibs+$1
//SEG7 [3] phi from main to main::@1
b1_from_main:
//SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- zpby1=coby1
@ -629,23 +662,23 @@ main: {
jmp b1
//SEG11 main::@1
b1:
//SEG12 [4] (byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- zpby1=cowo1_staridx_zpby2
//SEG12 [4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- zpby1=cowo1_staridx_zpby2
ldx i
lda $1100,x
lda fibs,x
sta _1
//SEG13 [5] (byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ] -- zpby1=cowo1_staridx_zpby2
//SEG13 [5] (byte~) main::$3 ← (const byte[15]) fibs#0+(byte) 1 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ] -- zpby1=cowo1_staridx_zpby2
ldx i
lda $1101,x
lda fibs+$1,x
sta _3
//SEG14 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- zpby1=zpby2_plus_zpby3
lda _1
clc
adc _3
sta _4
//SEG15 [7] *((word) 4354 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_zpby1=zpby2
//SEG15 [7] *((const byte[15]) fibs#0+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_zpby1=zpby2
lda _4
ldx i
sta $1102,x
sta fibs+$2,x
//SEG16 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- zpby1=_inc_zpby1
inc i
//SEG17 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- zpby1_lt_coby1_then_la1
@ -659,10 +692,10 @@ main: {
rts
}
Statement [1] *((word) 4352) ← (byte) 0 [ ] always clobbers reg byte a
Statement [2] *((word) 4353) ← (byte) 1 [ ] always clobbers reg byte a
Statement [1] *((word) 4352) ← (byte) 0 [ ] always clobbers reg byte a
Statement [2] *((word) 4353) ← (byte) 1 [ ] always clobbers reg byte a
Statement [1] *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0 [ ] always clobbers reg byte a
Statement [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] always clobbers reg byte a
Statement [1] *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0 [ ] always clobbers reg byte a
Statement [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] always clobbers reg byte a
Equivalence Class zp ZP_BYTE:4 [ main::$3 ] has ALU potential.
REGISTER UPLIFT POTENTIAL REGISTERS
Potential registers zp ZP_BYTE:2 [ main::i#2 main::i#1 ] : zp ZP_BYTE:2 , reg byte a , reg byte x , reg byte y ,
@ -719,7 +752,8 @@ Removing instruction jmp b1
Removing instruction jmp breturn
Succesful ASM optimization Pass5NextJumpElimination
ASSEMBLER
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const fibs = $1100
//SEG1 @begin
bbegin:
//SEG2 [0] call main param-assignment [ ]
@ -728,12 +762,12 @@ bbegin:
bend:
//SEG4 main
main: {
//SEG5 [1] *((word) 4352) ← (byte) 0 [ ] -- _star_cowo1=coby2
//SEG5 [1] *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0 [ ] -- _star_cowo1=coby2
lda #$0
sta $1100
//SEG6 [2] *((word) 4353) ← (byte) 1 [ ] -- _star_cowo1=coby2
sta fibs+$0
//SEG6 [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] -- _star_cowo1=coby2
lda #$1
sta $1101
sta fibs+$1
//SEG7 [3] phi from main to main::@1
b1_from_main:
//SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1
@ -744,15 +778,15 @@ main: {
//SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy
//SEG11 main::@1
b1:
//SEG12 [4] (byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby
lda $1100,x
//SEG13 [5] (byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
// [5] main::$3 ← 4353 *idx main::i#2 // ALU
//SEG12 [4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby
lda fibs,x
//SEG13 [5] (byte~) main::$3 ← (const byte[15]) fibs#0+(byte) 1 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
// [5] main::$3 ← fibs#0+1 *idx main::i#2 // ALU
//SEG14 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- aby=aby_plus_cowo1_staridx_xby
clc
adc $1101,x
//SEG15 [7] *((word) 4354 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby
sta $1102,x
adc fibs+$1,x
//SEG15 [7] *((const byte[15]) fibs#0+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby
sta fibs+$2,x
//SEG16 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby
inx
//SEG17 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1
@ -768,7 +802,8 @@ Replacing label b1_from_b1 with b1
Removing instruction b1_from_b1:
Succesful ASM optimization Pass5RedundantLabelElimination
ASSEMBLER
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const fibs = $1100
//SEG1 @begin
bbegin:
//SEG2 [0] call main param-assignment [ ]
@ -777,12 +812,12 @@ bbegin:
bend:
//SEG4 main
main: {
//SEG5 [1] *((word) 4352) ← (byte) 0 [ ] -- _star_cowo1=coby2
//SEG5 [1] *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0 [ ] -- _star_cowo1=coby2
lda #$0
sta $1100
//SEG6 [2] *((word) 4353) ← (byte) 1 [ ] -- _star_cowo1=coby2
sta fibs+$0
//SEG6 [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] -- _star_cowo1=coby2
lda #$1
sta $1101
sta fibs+$1
//SEG7 [3] phi from main to main::@1
b1_from_main:
//SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1
@ -792,15 +827,15 @@ main: {
//SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy
//SEG11 main::@1
b1:
//SEG12 [4] (byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby
lda $1100,x
//SEG13 [5] (byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
// [5] main::$3 ← 4353 *idx main::i#2 // ALU
//SEG12 [4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby
lda fibs,x
//SEG13 [5] (byte~) main::$3 ← (const byte[15]) fibs#0+(byte) 1 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
// [5] main::$3 ← fibs#0+1 *idx main::i#2 // ALU
//SEG14 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- aby=aby_plus_cowo1_staridx_xby
clc
adc $1101,x
//SEG15 [7] *((word) 4354 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby
sta $1102,x
adc fibs+$1,x
//SEG15 [7] *((const byte[15]) fibs#0+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby
sta fibs+$2,x
//SEG16 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby
inx
//SEG17 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1
@ -818,19 +853,20 @@ Removing instruction b1_from_main:
Removing instruction breturn:
Succesful ASM optimization Pass5UnusedLabelElimination
ASSEMBLER
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const fibs = $1100
//SEG1 @begin
//SEG2 [0] call main param-assignment [ ]
jsr main
//SEG3 @end
//SEG4 main
main: {
//SEG5 [1] *((word) 4352) ← (byte) 0 [ ] -- _star_cowo1=coby2
//SEG5 [1] *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0 [ ] -- _star_cowo1=coby2
lda #$0
sta $1100
//SEG6 [2] *((word) 4353) ← (byte) 1 [ ] -- _star_cowo1=coby2
sta fibs+$0
//SEG6 [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] -- _star_cowo1=coby2
lda #$1
sta $1101
sta fibs+$1
//SEG7 [3] phi from main to main::@1
//SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1
ldx #$0
@ -839,15 +875,15 @@ main: {
//SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy
//SEG11 main::@1
b1:
//SEG12 [4] (byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby
lda $1100,x
//SEG13 [5] (byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
// [5] main::$3 ← 4353 *idx main::i#2 // ALU
//SEG12 [4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby
lda fibs,x
//SEG13 [5] (byte~) main::$3 ← (const byte[15]) fibs#0+(byte) 1 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
// [5] main::$3 ← fibs#0+1 *idx main::i#2 // ALU
//SEG14 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- aby=aby_plus_cowo1_staridx_xby
clc
adc $1101,x
//SEG15 [7] *((word) 4354 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby
sta $1102,x
adc fibs+$1,x
//SEG15 [7] *((const byte[15]) fibs#0+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby
sta fibs+$2,x
//SEG16 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby
inx
//SEG17 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1
@ -861,19 +897,20 @@ main: {
Removing instruction jmp b1
Succesful ASM optimization Pass5NextJumpElimination
ASSEMBLER
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const fibs = $1100
//SEG1 @begin
//SEG2 [0] call main param-assignment [ ]
jsr main
//SEG3 @end
//SEG4 main
main: {
//SEG5 [1] *((word) 4352) ← (byte) 0 [ ] -- _star_cowo1=coby2
//SEG5 [1] *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0 [ ] -- _star_cowo1=coby2
lda #$0
sta $1100
//SEG6 [2] *((word) 4353) ← (byte) 1 [ ] -- _star_cowo1=coby2
sta fibs+$0
//SEG6 [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] -- _star_cowo1=coby2
lda #$1
sta $1101
sta fibs+$1
//SEG7 [3] phi from main to main::@1
//SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1
ldx #$0
@ -881,15 +918,15 @@ main: {
//SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy
//SEG11 main::@1
b1:
//SEG12 [4] (byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby
lda $1100,x
//SEG13 [5] (byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
// [5] main::$3 ← 4353 *idx main::i#2 // ALU
//SEG12 [4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby
lda fibs,x
//SEG13 [5] (byte~) main::$3 ← (const byte[15]) fibs#0+(byte) 1 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
// [5] main::$3 ← fibs#0+1 *idx main::i#2 // ALU
//SEG14 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- aby=aby_plus_cowo1_staridx_xby
clc
adc $1101,x
//SEG15 [7] *((word) 4354 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby
sta $1102,x
adc fibs+$1,x
//SEG15 [7] *((const byte[15]) fibs#0+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby
sta fibs+$2,x
//SEG16 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby
inx
//SEG17 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1
@ -904,6 +941,7 @@ FINAL SYMBOL TABLE
(label) @begin
(label) @end
(byte[15]) fibs
(const byte[15]) fibs#0 = (word) 4352
(void()) main()
(byte~) main::$1 reg byte a 11.0
(byte~) main::$3 reg byte alu 22.0
@ -920,19 +958,20 @@ reg byte alu [ main::$3 ]
reg byte a [ main::$4 ]
FINAL CODE
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const fibs = $1100
//SEG1 @begin
//SEG2 [0] call main param-assignment [ ]
jsr main
//SEG3 @end
//SEG4 main
main: {
//SEG5 [1] *((word) 4352) ← (byte) 0 [ ] -- _star_cowo1=coby2
//SEG5 [1] *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0 [ ] -- _star_cowo1=coby2
lda #$0
sta $1100
//SEG6 [2] *((word) 4353) ← (byte) 1 [ ] -- _star_cowo1=coby2
sta fibs+$0
//SEG6 [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] -- _star_cowo1=coby2
lda #$1
sta $1101
sta fibs+$1
//SEG7 [3] phi from main to main::@1
//SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1
ldx #$0
@ -940,15 +979,15 @@ main: {
//SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy
//SEG11 main::@1
b1:
//SEG12 [4] (byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby
lda $1100,x
//SEG13 [5] (byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
// [5] main::$3 ← 4353 *idx main::i#2 // ALU
//SEG12 [4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby
lda fibs,x
//SEG13 [5] (byte~) main::$3 ← (const byte[15]) fibs#0+(byte) 1 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
// [5] main::$3 ← fibs#0+1 *idx main::i#2 // ALU
//SEG14 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- aby=aby_plus_cowo1_staridx_xby
clc
adc $1101,x
//SEG15 [7] *((word) 4354 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby
sta $1102,x
adc fibs+$1,x
//SEG15 [7] *((const byte[15]) fibs#0+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby
sta fibs+$2,x
//SEG16 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby
inx
//SEG17 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1

1
src/main/java/dk/camelot64/kickc/test/ref/fibmem.sym
View File

@ -1,6 +1,7 @@
(label) @begin
(label) @end
(byte[15]) fibs
(const byte[15]) fibs#0 = (word) 4352
(void()) main()
(byte~) main::$1 reg byte a 11.0
(byte~) main::$3 reg byte alu 22.0

4
src/main/java/dk/camelot64/kickc/test/ref/flipper-rex2.asm
View File

@ -28,9 +28,9 @@ plot: {
.label y = 4
lda #$10
sta y
lda #<(SCREEN+($5*$28))+$c
lda #<SCREEN+(($5*$28)+$c)
sta line
lda #>(SCREEN+($5*$28))+$c
lda #>SCREEN+(($5*$28)+$c)
sta line+$1
ldx #$0
b1:

765
src/main/java/dk/camelot64/kickc/test/ref/flipper-rex2.log
View File

File diff suppressed because it is too large Load Diff

13
src/main/java/dk/camelot64/kickc/test/ref/forclassicmin.log
View File

@ -282,8 +282,8 @@ main::@return: scope:[main] from main::@1
to:@end
@end: scope:[] from @1
Constant (const byte*) SCREEN#0
Constant (const byte) main::i#0
Constant (const byte*) SCREEN#0 = 1024
Constant (const byte) main::i#0 = 0
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
@ -305,8 +305,8 @@ main::@return: scope:[main] from main::@1
to:@end
@end: scope:[] from @1
Redundant Phi (byte*) SCREEN#1 (const byte*) SCREEN#0
Succesful SSA optimization Pass2RedundantPhiElimination
Constant (const byte*) SCREEN#1 = SCREEN#0
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
to:@1
@ -314,7 +314,7 @@ main: scope:[main] from @1
to:main::@1
main::@1: scope:[main] from main main::@1
(byte) main::i#2 ← phi( main/(const byte) main::i#0 main::@1/(byte) main::i#1 )
*((const byte*) SCREEN#0 + (byte) main::i#2) ← (byte) main::i#2
*((const byte*) SCREEN#1 + (byte) main::i#2) ← (byte) main::i#2
(byte) main::i#1 ← ++ (byte) main::i#2
if((byte) main::i#1!=(byte) 100) goto main::@1
to:main::@return
@ -326,6 +326,9 @@ main::@return: scope:[main] from main::@1
to:@end
@end: scope:[] from @1
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Constant inlined SCREEN#1 = (const byte*) SCREEN#0
Constant inlined main::i#0 = (byte) 0
Succesful SSA optimization Pass2ConstantInlining
CONTROL FLOW GRAPH

141
src/main/java/dk/camelot64/kickc/test/ref/forrangemin.log
View File

@ -434,10 +434,10 @@ main::@return: scope:[main] from main::@2
to:@end
@end: scope:[] from @1
Constant (const byte*) SCREEN1#0
Constant (const byte*) SCREEN2#0
Constant (const byte) main::i#0
Constant (const byte) main::j#0
Constant (const byte*) SCREEN1#0 = 1024
Constant (const byte*) SCREEN2#0 = 1280
Constant (const byte) main::i#0 = 0
Constant (const byte) main::j#0 = 100
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
@ -469,6 +469,68 @@ main::@return: scope:[main] from main::@2
to:@end
@end: scope:[] from @1
Constant (const byte*) SCREEN1#1 = SCREEN1#0
Constant (const byte*) SCREEN2#2 = SCREEN2#0
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
to:@1
main: scope:[main] from @1
to:main::@1
main::@1: scope:[main] from main main::@1
(byte) main::i#2 ← phi( main/(const byte) main::i#0 main::@1/(byte) main::i#1 )
*((const byte*) SCREEN1#1 + (byte) main::i#2) ← (byte) main::i#2
(byte) main::i#1 ← ++ (byte) main::i#2
if((byte) main::i#1!=(byte) 0) goto main::@1
to:main::@3
main::@3: scope:[main] from main::@1
to:main::@2
main::@2: scope:[main] from main::@2 main::@3
(byte*) SCREEN2#1 ← phi( main::@3/(const byte*) SCREEN2#2 )
(byte) main::j#2 ← phi( main::@2/(byte) main::j#1 main::@3/(const byte) main::j#0 )
*((byte*) SCREEN2#1 + (byte) main::j#2) ← (byte) main::j#2
(byte) main::j#1 ← -- (byte) main::j#2
if((byte) main::j#1!=(byte) 255) goto main::@2
to:main::@return
main::@return: scope:[main] from main::@2
return
to:@return
@1: scope:[] from @begin
call main param-assignment
to:@end
@end: scope:[] from @1
Constant (const byte*) SCREEN2#1 = SCREEN2#2
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
to:@1
main: scope:[main] from @1
to:main::@1
main::@1: scope:[main] from main main::@1
(byte) main::i#2 ← phi( main/(const byte) main::i#0 main::@1/(byte) main::i#1 )
*((const byte*) SCREEN1#1 + (byte) main::i#2) ← (byte) main::i#2
(byte) main::i#1 ← ++ (byte) main::i#2
if((byte) main::i#1!=(byte) 0) goto main::@1
to:main::@3
main::@3: scope:[main] from main::@1
to:main::@2
main::@2: scope:[main] from main::@2 main::@3
(byte) main::j#2 ← phi( main::@2/(byte) main::j#1 main::@3/(const byte) main::j#0 )
*((const byte*) SCREEN2#1 + (byte) main::j#2) ← (byte) main::j#2
(byte) main::j#1 ← -- (byte) main::j#2
if((byte) main::j#1!=(byte) 255) goto main::@2
to:main::@return
main::@return: scope:[main] from main::@2
return
to:@return
@1: scope:[] from @begin
call main param-assignment
to:@end
@end: scope:[] from @1
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::j#2
Culled Empty Block (label) main::@3
Succesful SSA optimization Pass2CullEmptyBlocks
CONTROL FLOW GRAPH
@ -477,74 +539,14 @@ CONTROL FLOW GRAPH
main: scope:[main] from @1
to:main::@1
main::@1: scope:[main] from main main::@1
(byte*) SCREEN2#2 ← phi( main/(const byte*) SCREEN2#0 )
(byte*) SCREEN1#1 ← phi( main/(const byte*) SCREEN1#0 )
(byte) main::i#2 ← phi( main/(const byte) main::i#0 main::@1/(byte) main::i#1 )
*((byte*) SCREEN1#1 + (byte) main::i#2) ← (byte) main::i#2
*((const byte*) SCREEN1#1 + (byte) main::i#2) ← (byte) main::i#2
(byte) main::i#1 ← ++ (byte) main::i#2
if((byte) main::i#1!=(byte) 0) goto main::@1
to:main::@2
main::@2: scope:[main] from main::@1 main::@2
(byte*) SCREEN2#1 ← phi( main::@1/(byte*) SCREEN2#2 )
(byte) main::j#2 ← phi( main::@2/(byte) main::j#1 main::@1/(const byte) main::j#0 )
*((byte*) SCREEN2#1 + (byte) main::j#2) ← (byte) main::j#2
(byte) main::j#1 ← -- (byte) main::j#2
if((byte) main::j#1!=(byte) 255) goto main::@2
to:main::@return
main::@return: scope:[main] from main::@2
return
to:@return
@1: scope:[] from @begin
call main param-assignment
to:@end
@end: scope:[] from @1
Alias (byte*) SCREEN2#1 = (byte*) SCREEN2#2
Succesful SSA optimization Pass2AliasElimination
CONTROL FLOW GRAPH
@begin: scope:[] from
to:@1
main: scope:[main] from @1
to:main::@1
main::@1: scope:[main] from main main::@1
(byte*) SCREEN2#1 ← phi( main/(const byte*) SCREEN2#0 )
(byte*) SCREEN1#1 ← phi( main/(const byte*) SCREEN1#0 )
(byte) main::i#2 ← phi( main/(const byte) main::i#0 main::@1/(byte) main::i#1 )
*((byte*) SCREEN1#1 + (byte) main::i#2) ← (byte) main::i#2
(byte) main::i#1 ← ++ (byte) main::i#2
if((byte) main::i#1!=(byte) 0) goto main::@1
to:main::@2
main::@2: scope:[main] from main::@1 main::@2
(byte) main::j#2 ← phi( main::@2/(byte) main::j#1 main::@1/(const byte) main::j#0 )
*((byte*) SCREEN2#1 + (byte) main::j#2) ← (byte) main::j#2
(byte) main::j#1 ← -- (byte) main::j#2
if((byte) main::j#1!=(byte) 255) goto main::@2
to:main::@return
main::@return: scope:[main] from main::@2
return
to:@return
@1: scope:[] from @begin
call main param-assignment
to:@end
@end: scope:[] from @1
Redundant Phi (byte*) SCREEN1#1 (const byte*) SCREEN1#0
Redundant Phi (byte*) SCREEN2#1 (const byte*) SCREEN2#0
Succesful SSA optimization Pass2RedundantPhiElimination
CONTROL FLOW GRAPH
@begin: scope:[] from
to:@1
main: scope:[main] from @1
to:main::@1
main::@1: scope:[main] from main main::@1
(byte) main::i#2 ← phi( main/(const byte) main::i#0 main::@1/(byte) main::i#1 )
*((const byte*) SCREEN1#0 + (byte) main::i#2) ← (byte) main::i#2
(byte) main::i#1 ← ++ (byte) main::i#2
if((byte) main::i#1!=(byte) 0) goto main::@1
to:main::@2
main::@2: scope:[main] from main::@1 main::@2
(byte) main::j#2 ← phi( main::@2/(byte) main::j#1 main::@1/(const byte) main::j#0 )
*((const byte*) SCREEN2#0 + (byte) main::j#2) ← (byte) main::j#2
*((const byte*) SCREEN2#1 + (byte) main::j#2) ← (byte) main::j#2
(byte) main::j#1 ← -- (byte) main::j#2
if((byte) main::j#1!=(byte) 255) goto main::@2
to:main::@return
@ -556,6 +558,13 @@ main::@return: scope:[main] from main::@2
to:@end
@end: scope:[] from @1
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::j#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::j#2
Constant inlined SCREEN1#1 = (const byte*) SCREEN1#0
Constant inlined SCREEN2#1 = (const byte*) SCREEN2#0
Constant inlined SCREEN2#2 = (const byte*) SCREEN2#0
Constant inlined main::j#0 = (byte) 100
Constant inlined main::i#0 = (byte) 0
Succesful SSA optimization Pass2ConstantInlining

11
src/main/java/dk/camelot64/kickc/test/ref/ifmin.log
View File

@ -417,8 +417,8 @@ main::@return: scope:[main] from main::@2
to:@return
@end: scope:[] from @begin
Constant (const byte*) SCREEN#0
Constant (const byte) main::i#0
Constant (const byte*) SCREEN#0 = 1024
Constant (const byte) main::i#0 = 0
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
@ -443,8 +443,8 @@ main::@return: scope:[main] from main::@2
to:@return
@end: scope:[] from @begin
Redundant Phi (byte*) SCREEN#1 (const byte*) SCREEN#0
Succesful SSA optimization Pass2RedundantPhiElimination
Constant (const byte*) SCREEN#1 = SCREEN#0
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
@ -460,13 +460,14 @@ main::@2: scope:[main] from main::@1 main::@3
if((byte) main::i#1<(byte) 100) goto main::@1
to:main::@return
main::@3: scope:[main] from main::@1
*((const byte*) SCREEN#0) ← (byte) main::i#2
*((const byte*) SCREEN#1) ← (byte) main::i#2
to:main::@2
main::@return: scope:[main] from main::@2
return
to:@return
@end: scope:[] from @begin
Constant inlined SCREEN#1 = (const byte*) SCREEN#0
Constant inlined main::i#0 = (byte) 0
Succesful SSA optimization Pass2ConstantInlining
CONTROL FLOW GRAPH

8
src/main/java/dk/camelot64/kickc/test/ref/liverange.log
View File

@ -361,8 +361,12 @@ inc::@return: scope:[inc] from inc
to:@return
@end: scope:[] from @3
Constant (const byte) i#0
Constant (const byte) main::a#0
Not aliassing across scopes: main::$0 inc::return#0
Not aliassing across scopes: main::$2 inc::return#0
Not aliassing across scopes: i#1 inc::$0
Not aliassing across scopes: inc::return#0 i#1
Constant (const byte) i#0 = 0
Constant (const byte) main::a#0 = 4
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from

4
src/main/java/dk/camelot64/kickc/test/ref/loopmin.log
View File

@ -281,8 +281,8 @@ CONTROL FLOW GRAPH
to:@2
@end: scope:[] from @2
Constant (const byte) i#0
Constant (const byte) s#0
Constant (const byte) i#0 = 10
Constant (const byte) s#0 = 0
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from

20
src/main/java/dk/camelot64/kickc/test/ref/loopnest.log
View File

@ -450,9 +450,9 @@ nest::@return: scope:[nest] from nest::@1
to:@return
@end: scope:[] from @begin
Constant (const byte*) SCREEN#0
Constant (const byte) main::i#0
Constant (const byte) nest::j#0
Constant (const byte*) SCREEN#0 = 1024
Constant (const byte) main::i#0 = 100
Constant (const byte) nest::j#0 = 100
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
@ -486,8 +486,8 @@ nest::@return: scope:[nest] from nest::@1
to:@return
@end: scope:[] from @begin
Alias (byte*) SCREEN#1 = (byte*) SCREEN#2
Succesful SSA optimization Pass2AliasElimination
Constant (const byte*) SCREEN#2 = SCREEN#0
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
@ -495,7 +495,6 @@ CONTROL FLOW GRAPH
main: scope:[main] from @begin
to:main::@1
main::@1: scope:[main] from main main::@3
(byte*) SCREEN#1 ← phi( main/(const byte*) SCREEN#0 )
(byte) main::i#2 ← phi( main/(const byte) main::i#0 main::@3/(byte) main::i#1 )
call nest param-assignment
to:main::@3
@ -509,6 +508,7 @@ main::@return: scope:[main] from main::@3
nest: scope:[nest] from main::@1
to:nest::@1
nest::@1: scope:[nest] from nest nest::@1
(byte*) SCREEN#1 ← phi( nest/(const byte*) SCREEN#2 )
(byte) nest::j#2 ← phi( nest/(const byte) nest::j#0 nest::@1/(byte) nest::j#1 )
*((byte*) SCREEN#1) ← (byte) nest::j#2
(byte) nest::j#1 ← -- (byte) nest::j#2
@ -519,8 +519,8 @@ nest::@return: scope:[nest] from nest::@1
to:@return
@end: scope:[] from @begin
Redundant Phi (byte*) SCREEN#1 (const byte*) SCREEN#0
Succesful SSA optimization Pass2RedundantPhiElimination
Constant (const byte*) SCREEN#1 = SCREEN#2
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
@ -542,7 +542,7 @@ nest: scope:[nest] from main::@1
to:nest::@1
nest::@1: scope:[nest] from nest nest::@1
(byte) nest::j#2 ← phi( nest/(const byte) nest::j#0 nest::@1/(byte) nest::j#1 )
*((const byte*) SCREEN#0) ← (byte) nest::j#2
*((const byte*) SCREEN#1) ← (byte) nest::j#2
(byte) nest::j#1 ← -- (byte) nest::j#2
if((byte) nest::j#1>(byte) 0) goto nest::@1
to:nest::@return
@ -551,6 +551,8 @@ nest::@return: scope:[nest] from nest::@1
to:@return
@end: scope:[] from @begin
Constant inlined SCREEN#2 = (const byte*) SCREEN#0
Constant inlined SCREEN#1 = (const byte*) SCREEN#0
Constant inlined main::i#0 = (byte) 100
Constant inlined nest::j#0 = (byte) 100
Succesful SSA optimization Pass2ConstantInlining

30
src/main/java/dk/camelot64/kickc/test/ref/loopnest2.log
View File

@ -1016,13 +1016,13 @@ nest2::@return: scope:[nest2] from nest2::@3
to:@return
@end: scope:[] from @begin
Constant (const byte*) SCREEN#0
Constant (const byte) main::i#0
Constant (const byte) main::j#0
Constant (const byte) nest1::i#0
Constant (const byte) nest1::j#0
Constant (const byte) nest2::i#0
Constant (const byte) nest2::j#0
Constant (const byte*) SCREEN#0 = 1024
Constant (const byte) main::i#0 = 100
Constant (const byte) main::j#0 = 100
Constant (const byte) nest1::i#0 = 100
Constant (const byte) nest1::j#0 = 100
Constant (const byte) nest2::i#0 = 100
Constant (const byte) nest2::j#0 = 100
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
@ -1242,7 +1242,7 @@ nest2::@return: scope:[nest2] from nest2::@3
to:@return
@end: scope:[] from @begin
Constant (const byte*) SCREEN#10
Constant (const byte*) SCREEN#10 = SCREEN#0
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
@ -1310,8 +1310,8 @@ nest2::@return: scope:[nest2] from nest2::@3
to:@return
@end: scope:[] from @begin
Alias (byte*) SCREEN#1 = (byte*) SCREEN#3
Succesful SSA optimization Pass2AliasElimination
Constant (const byte*) SCREEN#3 = SCREEN#10
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
@ -1339,7 +1339,6 @@ main::@return: scope:[main] from main::@3
nest1: scope:[nest1] from main::@2
to:nest1::@1
nest1::@1: scope:[nest1] from nest1 nest1::@3
(byte*) SCREEN#1 ← phi( nest1/(const byte*) SCREEN#10 )
(byte) nest1::i#2 ← phi( nest1/(const byte) nest1::i#0 nest1::@3/(byte) nest1::i#1 )
to:nest1::@2
nest1::@2: scope:[nest1] from nest1::@1 nest1::@5
@ -1361,6 +1360,7 @@ nest2: scope:[nest2] from nest1::@2
to:nest2::@1
nest2::@1: scope:[nest2] from nest2 nest2::@3
(byte) nest2::i#2 ← phi( nest2/(const byte) nest2::i#0 nest2::@3/(byte) nest2::i#1 )
(byte*) SCREEN#1 ← phi( nest2/(const byte*) SCREEN#3 )
to:nest2::@2
nest2::@2: scope:[nest2] from nest2::@1 nest2::@2
(byte) nest2::j#2 ← phi( nest2::@1/(const byte) nest2::j#0 nest2::@2/(byte) nest2::j#1 )
@ -1377,8 +1377,8 @@ nest2::@return: scope:[nest2] from nest2::@3
to:@return
@end: scope:[] from @begin
Redundant Phi (byte*) SCREEN#1 (const byte*) SCREEN#10
Succesful SSA optimization Pass2RedundantPhiElimination
Constant (const byte*) SCREEN#1 = SCREEN#3
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
@ -1430,7 +1430,7 @@ nest2::@1: scope:[nest2] from nest2 nest2::@3
to:nest2::@2
nest2::@2: scope:[nest2] from nest2::@1 nest2::@2
(byte) nest2::j#2 ← phi( nest2::@1/(const byte) nest2::j#0 nest2::@2/(byte) nest2::j#1 )
*((const byte*) SCREEN#10) ← (byte) nest2::j#2
*((const byte*) SCREEN#1) ← (byte) nest2::j#2
(byte) nest2::j#1 ← -- (byte) nest2::j#2
if((byte) nest2::j#1>(byte) 0) goto nest2::@2
to:nest2::@3
@ -1446,6 +1446,8 @@ nest2::@return: scope:[nest2] from nest2::@3
Constant inlined nest1::i#0 = (byte) 100
Constant inlined nest1::j#0 = (byte) 100
Constant inlined nest2::i#0 = (byte) 100
Constant inlined SCREEN#1 = (const byte*) SCREEN#0
Constant inlined SCREEN#3 = (const byte*) SCREEN#0
Constant inlined nest2::j#0 = (byte) 100
Constant inlined main::j#0 = (byte) 100
Constant inlined main::i#0 = (byte) 100

4
src/main/java/dk/camelot64/kickc/test/ref/loopsplit.log
View File

@ -418,8 +418,8 @@ main::@return: scope:[main] from main::@1
to:@return
@end: scope:[] from @begin
Constant (const byte) main::i#0
Constant (const byte) main::s#0
Constant (const byte) main::i#0 = 100
Constant (const byte) main::s#0 = 0
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from

5
src/main/java/dk/camelot64/kickc/test/ref/minus.asm
View File

@ -1,9 +1,10 @@
.const p = $1100
ldx #$5
b1:
txa
clc
adc #$4
sta $1100,x
adc #$2+$2
sta p,x
inx
cpx #$a
bcc b1

4
src/main/java/dk/camelot64/kickc/test/ref/minus.cfg
View File

@ -2,8 +2,8 @@
to:@1
@1: scope:[] from @1 @begin
[0] (byte) i#2 ← phi( @1/(byte) i#1 @begin/(byte) 5 ) [ i#2 ]
[1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ]
[2] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ]
[1] (byte~) $1 ← (byte) i#2 + (byte) 2+(byte) 2 [ i#2 $1 ]
[2] *((const byte[16]) p#0 + (byte) i#2) ← (byte~) $1 [ i#2 ]
[3] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ]
[4] if((byte) i#1<(byte) 10) goto @1 [ i#1 ]
to:@end

228
src/main/java/dk/camelot64/kickc/test/ref/minus.log
View File

@ -132,55 +132,18 @@ INITIAL SSA SYMBOL TABLE
(byte[16]) p#0
(byte[16]) p#1
Constant (byte[16]) p#0 (word) 4352
Constant (byte) i#0 (byte) 5
Succesful SSA optimization Pass2ConstantPropagation
CONTROL FLOW GRAPH
@begin: scope:[] from
to:@1
@1: scope:[] from @1 @begin
(byte[16]) p#1 ← phi( @1/(byte[16]) p#1 @begin/(word) 4352 )
(byte) i#2 ← phi( @1/(byte) i#1 @begin/(byte) 5 )
(byte~) $0 ← (byte) 2 + (byte) i#2
(byte~) $1 ← (byte~) $0 + (byte) 2
*((byte[16]) p#1 + (byte) i#2) ← (byte~) $1
(byte~) $2 ← (byte) i#2 + (byte) 1
(byte) i#1 ← (byte~) $2
(boolean~) $3 ← (byte) i#1 < (byte) 10
if((boolean~) $3) goto @1
to:@end
@end: scope:[] from @1
Multiple usages for variable. Not optimizing sub-constant (byte) i#2
Consolidated constant in assignment $1
Multiple usages for variable. Not optimizing sub-constant (byte) i#2
Succesful SSA optimization Pass2ConstantAdditionElimination
CONTROL FLOW GRAPH
@begin: scope:[] from
to:@1
@1: scope:[] from @1 @begin
(byte[16]) p#1 ← phi( @1/(byte[16]) p#1 @begin/(word) 4352 )
(byte) i#2 ← phi( @1/(byte) i#1 @begin/(byte) 5 )
(byte~) $0 ← (byte) i#2
(byte~) $1 ← (byte~) $0 + (byte) 4
*((byte[16]) p#1 + (byte) i#2) ← (byte~) $1
(byte~) $2 ← (byte) i#2 + (byte) 1
(byte) i#1 ← (byte~) $2
(boolean~) $3 ← (byte) i#1 < (byte) 10
if((boolean~) $3) goto @1
to:@end
@end: scope:[] from @1
Alias (byte) i#2 = (byte~) $0
Alias (byte) i#1 = (byte~) $2
Succesful SSA optimization Pass2AliasElimination
CONTROL FLOW GRAPH
@begin: scope:[] from
(byte[16]) p#0 ← (word) 4352
(byte) i#0 ← (byte) 5
to:@1
@1: scope:[] from @1 @begin
(byte[16]) p#1 ← phi( @1/(byte[16]) p#1 @begin/(word) 4352 )
(byte) i#2 ← phi( @1/(byte) i#1 @begin/(byte) 5 )
(byte~) $1 ← (byte) i#2 + (byte) 4
(byte[16]) p#1 ← phi( @1/(byte[16]) p#1 @begin/(byte[16]) p#0 )
(byte) i#2 ← phi( @1/(byte) i#1 @begin/(byte) i#0 )
(byte~) $0 ← (byte) 2 + (byte) i#2
(byte~) $1 ← (byte~) $0 + (byte) 2
*((byte[16]) p#1 + (byte) i#2) ← (byte~) $1
(byte) i#1 ← (byte) i#2 + (byte) 1
(boolean~) $3 ← (byte) i#1 < (byte) 10
@ -192,11 +155,14 @@ Self Phi Eliminated (byte[16]) p#1
Succesful SSA optimization Pass2SelfPhiElimination
CONTROL FLOW GRAPH
@begin: scope:[] from
(byte[16]) p#0 ← (word) 4352
(byte) i#0 ← (byte) 5
to:@1
@1: scope:[] from @1 @begin
(byte[16]) p#1 ← phi( @begin/(word) 4352 )
(byte) i#2 ← phi( @1/(byte) i#1 @begin/(byte) 5 )
(byte~) $1 ← (byte) i#2 + (byte) 4
(byte[16]) p#1 ← phi( @begin/(byte[16]) p#0 )
(byte) i#2 ← phi( @1/(byte) i#1 @begin/(byte) i#0 )
(byte~) $0 ← (byte) 2 + (byte) i#2
(byte~) $1 ← (byte~) $0 + (byte) 2
*((byte[16]) p#1 + (byte) i#2) ← (byte~) $1
(byte) i#1 ← (byte) i#2 + (byte) 1
(boolean~) $3 ← (byte) i#1 < (byte) 10
@ -208,26 +174,81 @@ Simple Condition (boolean~) $3 if((byte) i#1<(byte) 10) goto @1
Succesful SSA optimization Pass2ConditionalJumpSimplification
CONTROL FLOW GRAPH
@begin: scope:[] from
(byte[16]) p#0 ← (word) 4352
(byte) i#0 ← (byte) 5
to:@1
@1: scope:[] from @1 @begin
(byte[16]) p#1 ← phi( @begin/(word) 4352 )
(byte) i#2 ← phi( @1/(byte) i#1 @begin/(byte) 5 )
(byte~) $1 ← (byte) i#2 + (byte) 4
(byte[16]) p#1 ← phi( @begin/(byte[16]) p#0 )
(byte) i#2 ← phi( @1/(byte) i#1 @begin/(byte) i#0 )
(byte~) $0 ← (byte) 2 + (byte) i#2
(byte~) $1 ← (byte~) $0 + (byte) 2
*((byte[16]) p#1 + (byte) i#2) ← (byte~) $1
(byte) i#1 ← (byte) i#2 + (byte) 1
if((byte) i#1<(byte) 10) goto @1
to:@end
@end: scope:[] from @1
Constant (byte[16]) p#1 (word) 4352
Succesful SSA optimization Pass2ConstantPropagation
Constant (const byte[16]) p#0 = 4352
Constant (const byte) i#0 = 5
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
to:@1
@1: scope:[] from @1 @begin
(byte) i#2 ← phi( @1/(byte) i#1 @begin/(byte) 5 )
(byte~) $1 ← (byte) i#2 + (byte) 4
*((word) 4352 + (byte) i#2) ← (byte~) $1
(byte[16]) p#1 ← phi( @begin/(const byte[16]) p#0 )
(byte) i#2 ← phi( @1/(byte) i#1 @begin/(const byte) i#0 )
(byte~) $0 ← (byte) 2 + (byte) i#2
(byte~) $1 ← (byte~) $0 + (byte) 2
*((byte[16]) p#1 + (byte) i#2) ← (byte~) $1
(byte) i#1 ← (byte) i#2 + (byte) 1
if((byte) i#1<(byte) 10) goto @1
to:@end
@end: scope:[] from @1
Constant (const byte[16]) p#1 = p#0
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
to:@1
@1: scope:[] from @1 @begin
(byte) i#2 ← phi( @1/(byte) i#1 @begin/(const byte) i#0 )
(byte~) $0 ← (byte) 2 + (byte) i#2
(byte~) $1 ← (byte~) $0 + (byte) 2
*((const byte[16]) p#1 + (byte) i#2) ← (byte~) $1
(byte) i#1 ← (byte) i#2 + (byte) 1
if((byte) i#1<(byte) 10) goto @1
to:@end
@end: scope:[] from @1
Multiple usages for variable. Not optimizing sub-constant (byte) i#2
Consolidated constant in assignment $1
Multiple usages for variable. Not optimizing sub-constant (byte) i#2
Multiple usages for variable. Not optimizing sub-constant (byte) i#2
Succesful SSA optimization Pass2ConstantAdditionElimination
CONTROL FLOW GRAPH
@begin: scope:[] from
to:@1
@1: scope:[] from @1 @begin
(byte) i#2 ← phi( @1/(byte) i#1 @begin/(const byte) i#0 )
(byte~) $0 ← (byte) i#2
(byte~) $1 ← (byte~) $0 + (byte) 2+(byte) 2
*((const byte[16]) p#1 + (byte) i#2) ← (byte~) $1
(byte) i#1 ← (byte) i#2 + (byte) 1
if((byte) i#1<(byte) 10) goto @1
to:@end
@end: scope:[] from @1
Multiple usages for variable. Not optimizing sub-constant (byte) i#2
Multiple usages for variable. Not optimizing sub-constant (byte) i#2
Alias (byte) i#2 = (byte~) $0
Succesful SSA optimization Pass2AliasElimination
CONTROL FLOW GRAPH
@begin: scope:[] from
to:@1
@1: scope:[] from @1 @begin
(byte) i#2 ← phi( @1/(byte) i#1 @begin/(const byte) i#0 )
(byte~) $1 ← (byte) i#2 + (byte) 2+(byte) 2
*((const byte[16]) p#1 + (byte) i#2) ← (byte~) $1
(byte) i#1 ← (byte) i#2 + (byte) 1
if((byte) i#1<(byte) 10) goto @1
to:@end
@ -239,6 +260,21 @@ Multiple usages for variable. Not optimizing sub-constant (byte) i#2
Multiple usages for variable. Not optimizing sub-constant (byte) i#2
Multiple usages for variable. Not optimizing sub-constant (byte) i#2
Multiple usages for variable. Not optimizing sub-constant (byte) i#2
Constant inlined p#1 = (const byte[16]) p#0
Constant inlined i#0 = (byte) 5
Succesful SSA optimization Pass2ConstantInlining
CONTROL FLOW GRAPH
@begin: scope:[] from
to:@1
@1: scope:[] from @1 @begin
(byte) i#2 ← phi( @1/(byte) i#1 @begin/(byte) 5 )
(byte~) $1 ← (byte) i#2 + (byte) 2+(byte) 2
*((const byte[16]) p#0 + (byte) i#2) ← (byte~) $1
(byte) i#1 ← (byte) i#2 + (byte) 1
if((byte) i#1<(byte) 10) goto @1
to:@end
@end: scope:[] from @1
FINAL SYMBOL TABLE
(byte~) $1
(label) @1
@ -248,6 +284,7 @@ FINAL SYMBOL TABLE
(byte) i#1
(byte) i#2
(byte[16]) p
(const byte[16]) p#0 = (word) 4352
Block Sequence Planned @begin @1 @end
Added new block during phi lifting @3(between @1 and @1)
@ -257,8 +294,8 @@ CONTROL FLOW GRAPH - PHI LIFTED
to:@1
@1: scope:[] from @3 @begin
(byte) i#2 ← phi( @3/(byte~) i#3 @begin/(byte) 5 )
(byte~) $1 ← (byte) i#2 + (byte) 4
*((word) 4352 + (byte) i#2) ← (byte~) $1
(byte~) $1 ← (byte) i#2 + (byte) 2+(byte) 2
*((const byte[16]) p#0 + (byte) i#2) ← (byte~) $1
(byte) i#1 ← (byte) i#2 + (byte) 1
if((byte) i#1<(byte) 10) goto @3
to:@end
@ -276,8 +313,8 @@ CONTROL FLOW GRAPH - LIVE RANGES FOUND
to:@1
@1: scope:[] from @3 @begin
[0] (byte) i#2 ← phi( @3/(byte~) i#3 @begin/(byte) 5 ) [ i#2 ]
[1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ]
[2] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ]
[1] (byte~) $1 ← (byte) i#2 + (byte) 2+(byte) 2 [ i#2 $1 ]
[2] *((const byte[16]) p#0 + (byte) i#2) ← (byte~) $1 [ i#2 ]
[3] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ]
[4] if((byte) i#1<(byte) 10) goto @3 [ i#1 ]
to:@end
@ -298,8 +335,8 @@ CONTROL FLOW GRAPH - PHI MEM COALESCED
to:@1
@1: scope:[] from @1 @begin
[0] (byte) i#2 ← phi( @1/(byte) i#1 @begin/(byte) 5 ) [ i#2 ]
[1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ]
[2] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ]
[1] (byte~) $1 ← (byte) i#2 + (byte) 2+(byte) 2 [ i#2 $1 ]
[2] *((const byte[16]) p#0 + (byte) i#2) ← (byte~) $1 [ i#2 ]
[3] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ]
[4] if((byte) i#1<(byte) 10) goto @1 [ i#1 ]
to:@end
@ -337,7 +374,8 @@ Complete equivalence classes
Allocated zp ZP_BYTE:2 [ i#2 i#1 ]
Allocated zp ZP_BYTE:3 [ $1 ]
INITIAL ASM
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const p = $1100
.label _1 = 3
.label i = 2
//SEG1 @begin
@ -354,15 +392,15 @@ b1_from_b1:
jmp b1
//SEG6 @1
b1:
//SEG7 [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] -- zpby1=zpby2_plus_coby1
//SEG7 [1] (byte~) $1 ← (byte) i#2 + (byte) 2+(byte) 2 [ i#2 $1 ] -- zpby1=zpby2_plus_coby1
lda i
clc
adc #$4
adc #$2+$2
sta _1
//SEG8 [2] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_zpby1=zpby2
//SEG8 [2] *((const byte[16]) p#0 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_zpby1=zpby2
lda _1
ldx i
sta $1100,x
sta p,x
//SEG9 [3] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] -- zpby1=zpby1_plus_1
inc i
//SEG10 [4] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] -- zpby1_lt_coby1_then_la1
@ -373,9 +411,9 @@ b1:
//SEG11 @end
bend:
Statement [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] always clobbers reg byte a
Statement [1] (byte~) $1 ← (byte) i#2 + (byte) 2+(byte) 2 [ i#2 $1 ] always clobbers reg byte a
Removing always clobbered register reg byte a as potential for zp ZP_BYTE:2 [ i#2 i#1 ]
Statement [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] always clobbers reg byte a
Statement [1] (byte~) $1 ← (byte) i#2 + (byte) 2+(byte) 2 [ i#2 $1 ] always clobbers reg byte a
REGISTER UPLIFT POTENTIAL REGISTERS
Potential registers zp ZP_BYTE:2 [ i#2 i#1 ] : zp ZP_BYTE:2 , reg byte x , reg byte y ,
Potential registers zp ZP_BYTE:3 [ $1 ] : zp ZP_BYTE:3 , reg byte a , reg byte x , reg byte y ,
@ -388,7 +426,8 @@ Removing instruction jmp b1
Removing instruction jmp bend
Succesful ASM optimization Pass5NextJumpElimination
ASSEMBLER
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const p = $1100
//SEG1 @begin
bbegin:
//SEG2 [0] phi from @begin to @1
@ -401,12 +440,12 @@ b1_from_b1:
//SEG5 [0] phi (byte) i#2 = (byte) i#1 -- register_copy
//SEG6 @1
b1:
//SEG7 [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] -- aby=xby_plus_coby1
//SEG7 [1] (byte~) $1 ← (byte) i#2 + (byte) 2+(byte) 2 [ i#2 $1 ] -- aby=xby_plus_coby1
txa
clc
adc #$4
//SEG8 [2] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_xby=aby
sta $1100,x
adc #$2+$2
//SEG8 [2] *((const byte[16]) p#0 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_xby=aby
sta p,x
//SEG9 [3] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] -- xby=xby_plus_1
inx
//SEG10 [4] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] -- xby_lt_coby1_then_la1
@ -420,7 +459,8 @@ Removing instruction b1_from_bbegin:
Removing instruction b1_from_b1:
Succesful ASM optimization Pass5RedundantLabelElimination
ASSEMBLER
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const p = $1100
//SEG1 @begin
bbegin:
//SEG2 [0] phi from @begin to @1
@ -431,12 +471,12 @@ bbegin:
//SEG5 [0] phi (byte) i#2 = (byte) i#1 -- register_copy
//SEG6 @1
b1:
//SEG7 [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] -- aby=xby_plus_coby1
//SEG7 [1] (byte~) $1 ← (byte) i#2 + (byte) 2+(byte) 2 [ i#2 $1 ] -- aby=xby_plus_coby1
txa
clc
adc #$4
//SEG8 [2] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_xby=aby
sta $1100,x
adc #$2+$2
//SEG8 [2] *((const byte[16]) p#0 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_xby=aby
sta p,x
//SEG9 [3] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] -- xby=xby_plus_1
inx
//SEG10 [4] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] -- xby_lt_coby1_then_la1
@ -449,7 +489,8 @@ Removing instruction bbegin:
Removing instruction bend:
Succesful ASM optimization Pass5UnusedLabelElimination
ASSEMBLER
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const p = $1100
//SEG1 @begin
//SEG2 [0] phi from @begin to @1
//SEG3 [0] phi (byte) i#2 = (byte) 5 -- xby=coby1
@ -459,12 +500,12 @@ ASSEMBLER
//SEG5 [0] phi (byte) i#2 = (byte) i#1 -- register_copy
//SEG6 @1
b1:
//SEG7 [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] -- aby=xby_plus_coby1
//SEG7 [1] (byte~) $1 ← (byte) i#2 + (byte) 2+(byte) 2 [ i#2 $1 ] -- aby=xby_plus_coby1
txa
clc
adc #$4
//SEG8 [2] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_xby=aby
sta $1100,x
adc #$2+$2
//SEG8 [2] *((const byte[16]) p#0 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_xby=aby
sta p,x
//SEG9 [3] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] -- xby=xby_plus_1
inx
//SEG10 [4] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] -- xby_lt_coby1_then_la1
@ -475,7 +516,8 @@ b1:
Removing instruction jmp b1
Succesful ASM optimization Pass5NextJumpElimination
ASSEMBLER
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const p = $1100
//SEG1 @begin
//SEG2 [0] phi from @begin to @1
//SEG3 [0] phi (byte) i#2 = (byte) 5 -- xby=coby1
@ -484,12 +526,12 @@ ASSEMBLER
//SEG5 [0] phi (byte) i#2 = (byte) i#1 -- register_copy
//SEG6 @1
b1:
//SEG7 [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] -- aby=xby_plus_coby1
//SEG7 [1] (byte~) $1 ← (byte) i#2 + (byte) 2+(byte) 2 [ i#2 $1 ] -- aby=xby_plus_coby1
txa
clc
adc #$4
//SEG8 [2] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_xby=aby
sta $1100,x
adc #$2+$2
//SEG8 [2] *((const byte[16]) p#0 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_xby=aby
sta p,x
//SEG9 [3] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] -- xby=xby_plus_1
inx
//SEG10 [4] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] -- xby_lt_coby1_then_la1
@ -506,12 +548,14 @@ FINAL SYMBOL TABLE
(byte) i#1 reg byte x 16.5
(byte) i#2 reg byte x 14.666666666666666
(byte[16]) p
(const byte[16]) p#0 = (word) 4352
reg byte x [ i#2 i#1 ]
reg byte a [ $1 ]
FINAL CODE
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const p = $1100
//SEG1 @begin
//SEG2 [0] phi from @begin to @1
//SEG3 [0] phi (byte) i#2 = (byte) 5 -- xby=coby1
@ -520,12 +564,12 @@ FINAL CODE
//SEG5 [0] phi (byte) i#2 = (byte) i#1 -- register_copy
//SEG6 @1
b1:
//SEG7 [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] -- aby=xby_plus_coby1
//SEG7 [1] (byte~) $1 ← (byte) i#2 + (byte) 2+(byte) 2 [ i#2 $1 ] -- aby=xby_plus_coby1
txa
clc
adc #$4
//SEG8 [2] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_xby=aby
sta $1100,x
adc #$2+$2
//SEG8 [2] *((const byte[16]) p#0 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_xby=aby
sta p,x
//SEG9 [3] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] -- xby=xby_plus_1
inx
//SEG10 [4] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] -- xby_lt_coby1_then_la1

1
src/main/java/dk/camelot64/kickc/test/ref/minus.sym
View File

@ -6,6 +6,7 @@
(byte) i#1 reg byte x 16.5
(byte) i#2 reg byte x 14.666666666666666
(byte[16]) p
(const byte[16]) p#0 = (word) 4352
reg byte x [ i#2 i#1 ]
reg byte a [ $1 ]

5
src/main/java/dk/camelot64/kickc/test/ref/modglobal.asm
View File

@ -1,3 +1,4 @@
.const SCREEN = $400
.label cnt3 = 2
jsr main
main: {
@ -6,10 +7,10 @@ main: {
ldy #$0
ldx #$0
jsr inccnt
sta $400
sta SCREEN+$0
inx
jsr inccnt
sta $401
sta SCREEN+$1
rts
}
inccnt: {

4
src/main/java/dk/camelot64/kickc/test/ref/modglobal.cfg
View File

@ -8,13 +8,13 @@ main: scope:[main] from @begin
to:main::@1
main::@1: scope:[main] from main
[3] (byte~) main::$0 ← (byte) inccnt::return#0 [ main::$0 cnt#1 cnt2#1 cnt3#1 ]
[4] *((word) 1024) ← (byte~) main::$0 [ cnt#1 cnt2#1 cnt3#1 ]
[4] *((const byte[256]) SCREEN#0+(byte) 0) ← (byte~) main::$0 [ cnt#1 cnt2#1 cnt3#1 ]
[5] (byte) cnt#3 ← ++ (byte) cnt#1 [ cnt#3 cnt2#1 cnt3#1 ]
[6] call inccnt param-assignment [ inccnt::return#0 ]
to:main::@2
main::@2: scope:[main] from main::@1
[7] (byte~) main::$1 ← (byte) inccnt::return#0 [ main::$1 ]
[8] *((word) 1025) ← (byte~) main::$1 [ ]
[8] *((const byte[256]) SCREEN#0+(byte) 1) ← (byte~) main::$1 [ ]
to:main::@return
main::@return: scope:[main] from main::@2
[9] return [ ]

270
src/main/java/dk/camelot64/kickc/test/ref/modglobal.log
View File

@ -431,128 +431,48 @@ INITIAL SSA SYMBOL TABLE
(label) main::@2
(label) main::@return
Constant (byte) cnt#0 (byte) 0
Constant (byte) cnt2#0 (byte) 0
Constant (byte) cnt3#0 (byte) 0
Constant (byte[256]) SCREEN#0 (word) 1024
Succesful SSA optimization Pass2ConstantPropagation
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
to:@3
@3: scope:[] from @begin
(byte) cnt3#7 ← phi( @begin/(byte) cnt3#4 )
(byte) cnt2#7 ← phi( @begin/(byte) cnt2#4 )
(byte) cnt#8 ← phi( @begin/(byte) cnt#5 )
(byte) cnt#1 ← (byte) cnt#8
(byte) cnt2#1 ← (byte) cnt2#7
(byte) cnt3#1 ← (byte) cnt3#7
to:@end
main: scope:[main] from @begin
(byte[256]) SCREEN#3 ← phi( @begin/(word) 1024 )
(byte) cnt3#13 ← phi( @begin/(byte) 0 )
(byte) cnt2#13 ← phi( @begin/(byte) 0 )
(byte) cnt#14 ← phi( @begin/(byte) 0 )
call inccnt param-assignment
(byte) inccnt::return#0 ← (byte) inccnt::return#3
to:main::@1
main::@1: scope:[main] from main
(byte[256]) SCREEN#1 ← phi( main/(byte[256]) SCREEN#3 )
(byte) cnt3#8 ← phi( main/(byte) cnt3#6 )
(byte) cnt2#8 ← phi( main/(byte) cnt2#6 )
(byte) cnt#9 ← phi( main/(byte) cnt#7 )
(byte) inccnt::return#4 ← phi( main/(byte) inccnt::return#0 )
(byte~) main::$0 ← (byte) inccnt::return#4
(byte) cnt#2 ← (byte) cnt#9
(byte) cnt2#2 ← (byte) cnt2#8
(byte) cnt3#2 ← (byte) cnt3#8
*((byte[256]) SCREEN#1 + (byte) 0) ← (byte~) main::$0
(byte) cnt#3 ← ++ (byte) cnt#2
call inccnt param-assignment
(byte) inccnt::return#1 ← (byte) inccnt::return#3
to:main::@2
main::@2: scope:[main] from main::@1
(byte[256]) SCREEN#2 ← phi( main::@1/(byte[256]) SCREEN#1 )
(byte) cnt3#9 ← phi( main::@1/(byte) cnt3#6 )
(byte) cnt2#9 ← phi( main::@1/(byte) cnt2#6 )
(byte) cnt#10 ← phi( main::@1/(byte) cnt#7 )
(byte) inccnt::return#5 ← phi( main::@1/(byte) inccnt::return#1 )
(byte~) main::$1 ← (byte) inccnt::return#5
(byte) cnt#4 ← (byte) cnt#10
(byte) cnt2#3 ← (byte) cnt2#9
(byte) cnt3#3 ← (byte) cnt3#9
*((byte[256]) SCREEN#2 + (byte) 1) ← (byte~) main::$1
to:main::@return
main::@return: scope:[main] from main::@2
(byte) cnt3#10 ← phi( main::@2/(byte) cnt3#3 )
(byte) cnt2#10 ← phi( main::@2/(byte) cnt2#3 )
(byte) cnt#11 ← phi( main::@2/(byte) cnt#4 )
(byte) cnt#5 ← (byte) cnt#11
(byte) cnt2#4 ← (byte) cnt2#10
(byte) cnt3#4 ← (byte) cnt3#10
return
to:@return
inccnt: scope:[inccnt] from main main::@1
(byte) cnt3#11 ← phi( main/(byte) cnt3#13 main::@1/(byte) cnt3#2 )
(byte) cnt2#11 ← phi( main/(byte) cnt2#13 main::@1/(byte) cnt2#2 )
(byte) cnt#12 ← phi( main/(byte) cnt#14 main::@1/(byte) cnt#3 )
(byte) cnt#6 ← ++ (byte) cnt#12
(byte) cnt2#5 ← ++ (byte) cnt2#11
(byte) cnt3#5 ← ++ (byte) cnt3#11
(byte) inccnt::return#2 ← (byte) cnt#6
to:inccnt::@return
inccnt::@return: scope:[inccnt] from inccnt
(byte) cnt3#12 ← phi( inccnt/(byte) cnt3#5 )
(byte) cnt2#12 ← phi( inccnt/(byte) cnt2#5 )
(byte) cnt#13 ← phi( inccnt/(byte) cnt#6 )
(byte) inccnt::return#6 ← phi( inccnt/(byte) inccnt::return#2 )
(byte) inccnt::return#3 ← (byte) inccnt::return#6
(byte) cnt#7 ← (byte) cnt#13
(byte) cnt2#6 ← (byte) cnt2#12
(byte) cnt3#6 ← (byte) cnt3#12
return
to:@return
@end: scope:[] from @3
Not aliassing across scopes: main::$0 inccnt::return#4
Not aliassing across scopes: main::$1 inccnt::return#5
Not aliassing across scopes: inccnt::return#2 cnt#6
Alias (byte) cnt#1 = (byte) cnt#8 (byte) cnt#5 (byte) cnt#9 (byte) cnt#7 (byte) cnt#2 (byte) cnt#10 (byte) cnt#4 (byte) cnt#11 (byte) cnt#13 (byte) cnt#6
Alias (byte) cnt2#1 = (byte) cnt2#7 (byte) cnt2#4 (byte) cnt2#8 (byte) cnt2#6 (byte) cnt2#2 (byte) cnt2#9 (byte) cnt2#3 (byte) cnt2#10 (byte) cnt2#12 (byte) cnt2#5
Alias (byte) cnt3#1 = (byte) cnt3#7 (byte) cnt3#4 (byte) cnt3#8 (byte) cnt3#6 (byte) cnt3#2 (byte) cnt3#9 (byte) cnt3#3 (byte) cnt3#10 (byte) cnt3#12 (byte) cnt3#5
Alias (byte) cnt#0 = (byte) cnt#14
Alias (byte) cnt2#0 = (byte) cnt2#13
Alias (byte) cnt3#0 = (byte) cnt3#13
Alias (byte[256]) SCREEN#0 = (byte[256]) SCREEN#3 (byte[256]) SCREEN#1 (byte[256]) SCREEN#2
Alias (byte) inccnt::return#0 = (byte) inccnt::return#3 (byte) inccnt::return#4 (byte) inccnt::return#1 (byte) inccnt::return#5 (byte) inccnt::return#6 (byte) inccnt::return#2
Alias (byte[256]) SCREEN#1 = (byte[256]) SCREEN#3 (byte[256]) SCREEN#2
Succesful SSA optimization Pass2AliasElimination
CONTROL FLOW GRAPH
@begin: scope:[] from
(byte) cnt#0 ← (byte) 0
(byte) cnt2#0 ← (byte) 0
(byte) cnt3#0 ← (byte) 0
(byte[256]) SCREEN#0 ← (word) 1024
call main param-assignment
to:@3
@3: scope:[] from @begin
to:@end
main: scope:[main] from @begin
(byte[256]) SCREEN#1 ← phi( @begin/(word) 1024 )
(byte) cnt3#13 ← phi( @begin/(byte) 0 )
(byte) cnt2#13 ← phi( @begin/(byte) 0 )
(byte) cnt#14 ← phi( @begin/(byte) 0 )
call inccnt param-assignment
to:main::@1
main::@1: scope:[main] from main
(byte~) main::$0 ← (byte) inccnt::return#0
*((byte[256]) SCREEN#1 + (byte) 0) ← (byte~) main::$0
*((byte[256]) SCREEN#0 + (byte) 0) ← (byte~) main::$0
(byte) cnt#3 ← ++ (byte) cnt#1
call inccnt param-assignment
to:main::@2
main::@2: scope:[main] from main::@1
(byte~) main::$1 ← (byte) inccnt::return#0
*((byte[256]) SCREEN#1 + (byte) 1) ← (byte~) main::$1
*((byte[256]) SCREEN#0 + (byte) 1) ← (byte~) main::$1
to:main::@return
main::@return: scope:[main] from main::@2
return
to:@return
inccnt: scope:[inccnt] from main main::@1
(byte) cnt3#11 ← phi( main/(byte) cnt3#13 main::@1/(byte) cnt3#1 )
(byte) cnt2#11 ← phi( main/(byte) cnt2#13 main::@1/(byte) cnt2#1 )
(byte) cnt#12 ← phi( main/(byte) cnt#14 main::@1/(byte) cnt#3 )
(byte) cnt3#11 ← phi( main/(byte) cnt3#0 main::@1/(byte) cnt3#1 )
(byte) cnt2#11 ← phi( main/(byte) cnt2#0 main::@1/(byte) cnt2#1 )
(byte) cnt#12 ← phi( main/(byte) cnt#0 main::@1/(byte) cnt#3 )
(byte) cnt#1 ← ++ (byte) cnt#12
(byte) cnt2#1 ← ++ (byte) cnt2#11
(byte) cnt3#1 ← ++ (byte) cnt3#11
@ -563,11 +483,14 @@ inccnt::@return: scope:[inccnt] from inccnt
to:@return
@end: scope:[] from @3
Redundant Phi (byte) cnt#14 (byte) 0
Redundant Phi (byte) cnt2#13 (byte) 0
Redundant Phi (byte) cnt3#13 (byte) 0
Redundant Phi (byte[256]) SCREEN#1 (word) 1024
Succesful SSA optimization Pass2RedundantPhiElimination
Not aliassing across scopes: main::$0 inccnt::return#0
Not aliassing across scopes: main::$1 inccnt::return#0
Not aliassing across scopes: inccnt::return#0 cnt#1
Constant (const byte) cnt#0 = 0
Constant (const byte) cnt2#0 = 0
Constant (const byte) cnt3#0 = 0
Constant (const byte[256]) SCREEN#0 = 1024
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
@ -579,21 +502,60 @@ main: scope:[main] from @begin
to:main::@1
main::@1: scope:[main] from main
(byte~) main::$0 ← (byte) inccnt::return#0
*((word) 1024 + (byte) 0) ← (byte~) main::$0
*((const byte[256]) SCREEN#0 + (byte) 0) ← (byte~) main::$0
(byte) cnt#3 ← ++ (byte) cnt#1
call inccnt param-assignment
to:main::@2
main::@2: scope:[main] from main::@1
(byte~) main::$1 ← (byte) inccnt::return#0
*((word) 1024 + (byte) 1) ← (byte~) main::$1
*((const byte[256]) SCREEN#0 + (byte) 1) ← (byte~) main::$1
to:main::@return
main::@return: scope:[main] from main::@2
return
to:@return
inccnt: scope:[inccnt] from main main::@1
(byte) cnt3#11 ← phi( main/(byte) 0 main::@1/(byte) cnt3#1 )
(byte) cnt2#11 ← phi( main/(byte) 0 main::@1/(byte) cnt2#1 )
(byte) cnt#12 ← phi( main/(byte) 0 main::@1/(byte) cnt#3 )
(byte) cnt3#11 ← phi( main/(const byte) cnt3#0 main::@1/(byte) cnt3#1 )
(byte) cnt2#11 ← phi( main/(const byte) cnt2#0 main::@1/(byte) cnt2#1 )
(byte) cnt#12 ← phi( main/(const byte) cnt#0 main::@1/(byte) cnt#3 )
(byte) cnt#1 ← ++ (byte) cnt#12
(byte) cnt2#1 ← ++ (byte) cnt2#11
(byte) cnt3#1 ← ++ (byte) cnt3#11
(byte) inccnt::return#0 ← (byte) cnt#1
to:inccnt::@return
inccnt::@return: scope:[inccnt] from inccnt
return
to:@return
@end: scope:[] from @3
Consolidated assigned array index constant in assignment *(SCREEN#0+0)
Consolidated assigned array index constant in assignment *(SCREEN#0+1)
Succesful SSA optimization Pass2ConstantAdditionElimination
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
to:@3
@3: scope:[] from @begin
to:@end
main: scope:[main] from @begin
call inccnt param-assignment
to:main::@1
main::@1: scope:[main] from main
(byte~) main::$0 ← (byte) inccnt::return#0
*((const byte[256]) SCREEN#0+(byte) 0) ← (byte~) main::$0
(byte) cnt#3 ← ++ (byte) cnt#1
call inccnt param-assignment
to:main::@2
main::@2: scope:[main] from main::@1
(byte~) main::$1 ← (byte) inccnt::return#0
*((const byte[256]) SCREEN#0+(byte) 1) ← (byte~) main::$1
to:main::@return
main::@return: scope:[main] from main::@2
return
to:@return
inccnt: scope:[inccnt] from main main::@1
(byte) cnt3#11 ← phi( main/(const byte) cnt3#0 main::@1/(byte) cnt3#1 )
(byte) cnt2#11 ← phi( main/(const byte) cnt2#0 main::@1/(byte) cnt2#1 )
(byte) cnt#12 ← phi( main/(const byte) cnt#0 main::@1/(byte) cnt#3 )
(byte) cnt#1 ← ++ (byte) cnt#12
(byte) cnt2#1 ← ++ (byte) cnt2#11
(byte) cnt3#1 ← ++ (byte) cnt3#11
@ -615,21 +577,21 @@ main: scope:[main] from @begin
to:main::@1
main::@1: scope:[main] from main
(byte~) main::$0 ← (byte) inccnt::return#0
*((word) 1024 + (byte) 0) ← (byte~) main::$0
*((const byte[256]) SCREEN#0+(byte) 0) ← (byte~) main::$0
(byte) cnt#3 ← ++ (byte) cnt#1
call inccnt param-assignment
to:main::@2
main::@2: scope:[main] from main::@1
(byte~) main::$1 ← (byte) inccnt::return#0
*((word) 1024 + (byte) 1) ← (byte~) main::$1
*((const byte[256]) SCREEN#0+(byte) 1) ← (byte~) main::$1
to:main::@return
main::@return: scope:[main] from main::@2
return
to:@return
inccnt: scope:[inccnt] from main main::@1
(byte) cnt3#11 ← phi( main/(byte) 0 main::@1/(byte) cnt3#1 )
(byte) cnt2#11 ← phi( main/(byte) 0 main::@1/(byte) cnt2#1 )
(byte) cnt#12 ← phi( main/(byte) 0 main::@1/(byte) cnt#3 )
(byte) cnt3#11 ← phi( main/(const byte) cnt3#0 main::@1/(byte) cnt3#1 )
(byte) cnt2#11 ← phi( main/(const byte) cnt2#0 main::@1/(byte) cnt2#1 )
(byte) cnt#12 ← phi( main/(const byte) cnt#0 main::@1/(byte) cnt#3 )
(byte) cnt#1 ← ++ (byte) cnt#12
(byte) cnt2#1 ← ++ (byte) cnt2#11
(byte) cnt3#1 ← ++ (byte) cnt3#11
@ -640,9 +602,16 @@ inccnt::@return: scope:[inccnt] from inccnt
to:@return
@end: scope:[] from @begin
Consolidated assigned array index constant in assignment *(1024)
Consolidated assigned array index constant in assignment *(1025)
Succesful SSA optimization Pass2ConstantAdditionElimination
Not aliassing across scopes: main::$0 inccnt::return#0
Not aliassing across scopes: main::$1 inccnt::return#0
Not aliassing across scopes: inccnt::return#0 cnt#1
Not aliassing across scopes: main::$0 inccnt::return#0
Not aliassing across scopes: main::$1 inccnt::return#0
Not aliassing across scopes: inccnt::return#0 cnt#1
Constant inlined cnt#0 = (byte) 0
Constant inlined cnt3#0 = (byte) 0
Constant inlined cnt2#0 = (byte) 0
Succesful SSA optimization Pass2ConstantInlining
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
@ -652,13 +621,13 @@ main: scope:[main] from @begin
to:main::@1
main::@1: scope:[main] from main
(byte~) main::$0 ← (byte) inccnt::return#0
*((word) 1024) ← (byte~) main::$0
*((const byte[256]) SCREEN#0+(byte) 0) ← (byte~) main::$0
(byte) cnt#3 ← ++ (byte) cnt#1
call inccnt param-assignment
to:main::@2
main::@2: scope:[main] from main::@1
(byte~) main::$1 ← (byte) inccnt::return#0
*((word) 1025) ← (byte~) main::$1
*((const byte[256]) SCREEN#0+(byte) 1) ← (byte~) main::$1
to:main::@return
main::@return: scope:[main] from main::@2
return
@ -677,16 +646,11 @@ inccnt::@return: scope:[inccnt] from inccnt
to:@return
@end: scope:[] from @begin
Not aliassing across scopes: main::$0 inccnt::return#0
Not aliassing across scopes: main::$1 inccnt::return#0
Not aliassing across scopes: inccnt::return#0 cnt#1
Not aliassing across scopes: main::$0 inccnt::return#0
Not aliassing across scopes: main::$1 inccnt::return#0
Not aliassing across scopes: inccnt::return#0 cnt#1
FINAL SYMBOL TABLE
(label) @begin
(label) @end
(byte[256]) SCREEN
(const byte[256]) SCREEN#0 = (word) 1024
(byte) cnt
(byte) cnt#1
(byte) cnt#12
@ -720,7 +684,7 @@ main: scope:[main] from @begin
to:main::@1
main::@1: scope:[main] from main
(byte~) main::$0 ← (byte) inccnt::return#0
*((word) 1024) ← (byte~) main::$0
*((const byte[256]) SCREEN#0+(byte) 0) ← (byte~) main::$0
(byte) cnt#3 ← ++ (byte) cnt#1
(byte~) cnt#15 ← (byte) cnt#3
(byte~) cnt2#14 ← (byte) cnt2#1
@ -729,7 +693,7 @@ main::@1: scope:[main] from main
to:main::@2
main::@2: scope:[main] from main::@1
(byte~) main::$1 ← (byte) inccnt::return#0
*((word) 1025) ← (byte~) main::$1
*((const byte[256]) SCREEN#0+(byte) 1) ← (byte~) main::$1
to:main::@return
main::@return: scope:[main] from main::@2
return
@ -772,7 +736,7 @@ main: scope:[main] from @begin
to:main::@1
main::@1: scope:[main] from main
[3] (byte~) main::$0 ← (byte) inccnt::return#0 [ main::$0 cnt#1 cnt2#1 cnt3#1 ]
[4] *((word) 1024) ← (byte~) main::$0 [ cnt#1 cnt2#1 cnt3#1 ]
[4] *((const byte[256]) SCREEN#0+(byte) 0) ← (byte~) main::$0 [ cnt#1 cnt2#1 cnt3#1 ]
[5] (byte) cnt#3 ← ++ (byte) cnt#1 [ cnt#3 cnt2#1 cnt3#1 ]
[6] (byte~) cnt#15 ← (byte) cnt#3 [ cnt#15 cnt2#1 cnt3#1 ]
[7] (byte~) cnt2#14 ← (byte) cnt2#1 [ cnt#15 cnt2#14 cnt3#1 ]
@ -781,7 +745,7 @@ main::@1: scope:[main] from main
to:main::@2
main::@2: scope:[main] from main::@1
[10] (byte~) main::$1 ← (byte) inccnt::return#0 [ main::$1 ]
[11] *((word) 1025) ← (byte~) main::$1 [ ]
[11] *((const byte[256]) SCREEN#0+(byte) 1) ← (byte~) main::$1 [ ]
to:main::@return
main::@return: scope:[main] from main::@2
[12] return [ ]
@ -825,13 +789,13 @@ main: scope:[main] from @begin
to:main::@1
main::@1: scope:[main] from main
[3] (byte~) main::$0 ← (byte) inccnt::return#0 [ main::$0 cnt#1 cnt2#1 cnt3#1 ]
[4] *((word) 1024) ← (byte~) main::$0 [ cnt#1 cnt2#1 cnt3#1 ]
[4] *((const byte[256]) SCREEN#0+(byte) 0) ← (byte~) main::$0 [ cnt#1 cnt2#1 cnt3#1 ]
[5] (byte) cnt#3 ← ++ (byte) cnt#1 [ cnt#3 cnt2#1 cnt3#1 ]
[6] call inccnt param-assignment [ inccnt::return#0 ]
to:main::@2
main::@2: scope:[main] from main::@1
[7] (byte~) main::$1 ← (byte) inccnt::return#0 [ main::$1 ]
[8] *((word) 1025) ← (byte~) main::$1 [ ]
[8] *((const byte[256]) SCREEN#0+(byte) 1) ← (byte~) main::$1 [ ]
to:main::@return
main::@return: scope:[main] from main::@2
[9] return [ ]
@ -910,7 +874,8 @@ Allocated zp ZP_BYTE:6 [ main::$1 ]
Allocated zp ZP_BYTE:7 [ cnt#1 ]
Allocated zp ZP_BYTE:8 [ inccnt::return#0 ]
INITIAL ASM
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const SCREEN = $400
.label cnt = 7
.label cnt2 = 3
.label cnt3 = 4
@ -948,9 +913,9 @@ main: {
//SEG12 [3] (byte~) main::$0 ← (byte) inccnt::return#0 [ main::$0 cnt#1 cnt2#1 cnt3#1 ] -- zpby1=zpby2
lda inccnt.return
sta _0
//SEG13 [4] *((word) 1024) ← (byte~) main::$0 [ cnt#1 cnt2#1 cnt3#1 ] -- _star_cowo1=zpby1
//SEG13 [4] *((const byte[256]) SCREEN#0+(byte) 0) ← (byte~) main::$0 [ cnt#1 cnt2#1 cnt3#1 ] -- _star_cowo1=zpby1
lda _0
sta $400
sta SCREEN+$0
//SEG14 [5] (byte) cnt#3 ← ++ (byte) cnt#1 [ cnt#3 cnt2#1 cnt3#1 ] -- zpby1=_inc_zpby2
lda cnt
sta cnt_3
@ -968,9 +933,9 @@ main: {
//SEG21 [7] (byte~) main::$1 ← (byte) inccnt::return#0 [ main::$1 ] -- zpby1=zpby2
lda inccnt.return
sta _1
//SEG22 [8] *((word) 1025) ← (byte~) main::$1 [ ] -- _star_cowo1=zpby1
//SEG22 [8] *((const byte[256]) SCREEN#0+(byte) 1) ← (byte~) main::$1 [ ] -- _star_cowo1=zpby1
lda _1
sta $401
sta SCREEN+$1
jmp breturn
//SEG23 main::@return
breturn:
@ -1025,7 +990,8 @@ Removing instruction jmp breturn
Removing instruction jmp breturn
Succesful ASM optimization Pass5NextJumpElimination
ASSEMBLER
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const SCREEN = $400
.label cnt3 = 2
//SEG1 @begin
bbegin:
@ -1052,8 +1018,8 @@ main: {
b1:
//SEG12 [3] (byte~) main::$0 ← (byte) inccnt::return#0 [ main::$0 cnt#1 cnt2#1 cnt3#1 ]
// (byte~) main::$0 = (byte) inccnt::return#0 // register copy reg byte a
//SEG13 [4] *((word) 1024) ← (byte~) main::$0 [ cnt#1 cnt2#1 cnt3#1 ] -- _star_cowo1=aby
sta $400
//SEG13 [4] *((const byte[256]) SCREEN#0+(byte) 0) ← (byte~) main::$0 [ cnt#1 cnt2#1 cnt3#1 ] -- _star_cowo1=aby
sta SCREEN+$0
//SEG14 [5] (byte) cnt#3 ← ++ (byte) cnt#1 [ cnt#3 cnt2#1 cnt3#1 ] -- xby=_inc_xby
inx
//SEG15 [6] call inccnt param-assignment [ inccnt::return#0 ]
@ -1067,8 +1033,8 @@ main: {
b2:
//SEG21 [7] (byte~) main::$1 ← (byte) inccnt::return#0 [ main::$1 ]
// (byte~) main::$1 = (byte) inccnt::return#0 // register copy reg byte a
//SEG22 [8] *((word) 1025) ← (byte~) main::$1 [ ] -- _star_cowo1=aby
sta $401
//SEG22 [8] *((const byte[256]) SCREEN#0+(byte) 1) ← (byte~) main::$1 [ ] -- _star_cowo1=aby
sta SCREEN+$1
//SEG23 main::@return
breturn:
//SEG24 [9] return [ ]
@ -1093,7 +1059,8 @@ inccnt: {
Removing instruction main_from_bbegin:
Succesful ASM optimization Pass5RedundantLabelElimination
ASSEMBLER
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const SCREEN = $400
.label cnt3 = 2
//SEG1 @begin
bbegin:
@ -1119,8 +1086,8 @@ main: {
b1:
//SEG12 [3] (byte~) main::$0 ← (byte) inccnt::return#0 [ main::$0 cnt#1 cnt2#1 cnt3#1 ]
// (byte~) main::$0 = (byte) inccnt::return#0 // register copy reg byte a
//SEG13 [4] *((word) 1024) ← (byte~) main::$0 [ cnt#1 cnt2#1 cnt3#1 ] -- _star_cowo1=aby
sta $400
//SEG13 [4] *((const byte[256]) SCREEN#0+(byte) 0) ← (byte~) main::$0 [ cnt#1 cnt2#1 cnt3#1 ] -- _star_cowo1=aby
sta SCREEN+$0
//SEG14 [5] (byte) cnt#3 ← ++ (byte) cnt#1 [ cnt#3 cnt2#1 cnt3#1 ] -- xby=_inc_xby
inx
//SEG15 [6] call inccnt param-assignment [ inccnt::return#0 ]
@ -1134,8 +1101,8 @@ main: {
b2:
//SEG21 [7] (byte~) main::$1 ← (byte) inccnt::return#0 [ main::$1 ]
// (byte~) main::$1 = (byte) inccnt::return#0 // register copy reg byte a
//SEG22 [8] *((word) 1025) ← (byte~) main::$1 [ ] -- _star_cowo1=aby
sta $401
//SEG22 [8] *((const byte[256]) SCREEN#0+(byte) 1) ← (byte~) main::$1 [ ] -- _star_cowo1=aby
sta SCREEN+$1
//SEG23 main::@return
breturn:
//SEG24 [9] return [ ]
@ -1167,7 +1134,8 @@ Removing instruction breturn:
Removing instruction breturn:
Succesful ASM optimization Pass5UnusedLabelElimination
ASSEMBLER
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const SCREEN = $400
.label cnt3 = 2
//SEG1 @begin
//SEG2 [0] call main param-assignment [ ]
@ -1189,8 +1157,8 @@ main: {
//SEG11 main::@1
//SEG12 [3] (byte~) main::$0 ← (byte) inccnt::return#0 [ main::$0 cnt#1 cnt2#1 cnt3#1 ]
// (byte~) main::$0 = (byte) inccnt::return#0 // register copy reg byte a
//SEG13 [4] *((word) 1024) ← (byte~) main::$0 [ cnt#1 cnt2#1 cnt3#1 ] -- _star_cowo1=aby
sta $400
//SEG13 [4] *((const byte[256]) SCREEN#0+(byte) 0) ← (byte~) main::$0 [ cnt#1 cnt2#1 cnt3#1 ] -- _star_cowo1=aby
sta SCREEN+$0
//SEG14 [5] (byte) cnt#3 ← ++ (byte) cnt#1 [ cnt#3 cnt2#1 cnt3#1 ] -- xby=_inc_xby
inx
//SEG15 [6] call inccnt param-assignment [ inccnt::return#0 ]
@ -1202,8 +1170,8 @@ main: {
//SEG20 main::@2
//SEG21 [7] (byte~) main::$1 ← (byte) inccnt::return#0 [ main::$1 ]
// (byte~) main::$1 = (byte) inccnt::return#0 // register copy reg byte a
//SEG22 [8] *((word) 1025) ← (byte~) main::$1 [ ] -- _star_cowo1=aby
sta $401
//SEG22 [8] *((const byte[256]) SCREEN#0+(byte) 1) ← (byte~) main::$1 [ ] -- _star_cowo1=aby
sta SCREEN+$1
//SEG23 main::@return
//SEG24 [9] return [ ]
rts
@ -1227,6 +1195,7 @@ FINAL SYMBOL TABLE
(label) @begin
(label) @end
(byte[256]) SCREEN
(const byte[256]) SCREEN#0 = (word) 1024
(byte) cnt
(byte) cnt#1 reg byte x 0.75
(byte) cnt#12 reg byte x 4.0
@ -1257,7 +1226,8 @@ reg byte x [ cnt#1 ]
reg byte a [ inccnt::return#0 ]
FINAL CODE
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const SCREEN = $400
.label cnt3 = 2
//SEG1 @begin
//SEG2 [0] call main param-assignment [ ]
@ -1279,8 +1249,8 @@ main: {
//SEG11 main::@1
//SEG12 [3] (byte~) main::$0 ← (byte) inccnt::return#0 [ main::$0 cnt#1 cnt2#1 cnt3#1 ]
// (byte~) main::$0 = (byte) inccnt::return#0 // register copy reg byte a
//SEG13 [4] *((word) 1024) ← (byte~) main::$0 [ cnt#1 cnt2#1 cnt3#1 ] -- _star_cowo1=aby
sta $400
//SEG13 [4] *((const byte[256]) SCREEN#0+(byte) 0) ← (byte~) main::$0 [ cnt#1 cnt2#1 cnt3#1 ] -- _star_cowo1=aby
sta SCREEN+$0
//SEG14 [5] (byte) cnt#3 ← ++ (byte) cnt#1 [ cnt#3 cnt2#1 cnt3#1 ] -- xby=_inc_xby
inx
//SEG15 [6] call inccnt param-assignment [ inccnt::return#0 ]
@ -1292,8 +1262,8 @@ main: {
//SEG20 main::@2
//SEG21 [7] (byte~) main::$1 ← (byte) inccnt::return#0 [ main::$1 ]
// (byte~) main::$1 = (byte) inccnt::return#0 // register copy reg byte a
//SEG22 [8] *((word) 1025) ← (byte~) main::$1 [ ] -- _star_cowo1=aby
sta $401
//SEG22 [8] *((const byte[256]) SCREEN#0+(byte) 1) ← (byte~) main::$1 [ ] -- _star_cowo1=aby
sta SCREEN+$1
//SEG23 main::@return
//SEG24 [9] return [ ]
rts

1
src/main/java/dk/camelot64/kickc/test/ref/modglobal.sym
View File

@ -1,6 +1,7 @@
(label) @begin
(label) @end
(byte[256]) SCREEN
(const byte[256]) SCREEN#0 = (word) 1024
(byte) cnt
(byte) cnt#1 reg byte x 0.75
(byte) cnt#12 reg byte x 4.0

5
src/main/java/dk/camelot64/kickc/test/ref/modglobalmin.asm
View File

@ -1,12 +1,13 @@
.const SCREEN = $400
jsr main
main: {
ldx #$0
jsr inccnt
stx $400
stx SCREEN+$0
inx
jsr inccnt
inx
stx $401
stx SCREEN+$1
rts
}
inccnt: {

4
src/main/java/dk/camelot64/kickc/test/ref/modglobalmin.cfg
View File

@ -7,13 +7,13 @@ main: scope:[main] from @begin
[2] call inccnt param-assignment [ cnt#10 ]
to:main::@1
main::@1: scope:[main] from main
[3] *((word) 1024) ← (byte) cnt#10 [ cnt#10 ]
[3] *((const byte[256]) SCREEN#0+(byte) 0) ← (byte) cnt#10 [ cnt#10 ]
[4] (byte) cnt#3 ← ++ (byte) cnt#10 [ cnt#3 ]
[5] call inccnt param-assignment [ cnt#10 ]
to:main::@2
main::@2: scope:[main] from main::@1
[6] (byte) cnt#1 ← ++ (byte) cnt#10 [ cnt#1 ]
[7] *((word) 1025) ← (byte) cnt#1 [ ]
[7] *((const byte[256]) SCREEN#0+(byte) 1) ← (byte) cnt#1 [ ]
to:main::@return
main::@return: scope:[main] from main::@2
[8] return [ ]

189
src/main/java/dk/camelot64/kickc/test/ref/modglobalmin.log
View File

@ -274,82 +274,36 @@ INITIAL SSA SYMBOL TABLE
(label) main::@2
(label) main::@return
Constant (byte) cnt#0 (byte) 0
Constant (byte[256]) SCREEN#0 (word) 1024
Succesful SSA optimization Pass2ConstantPropagation
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
to:@3
@3: scope:[] from @begin
(byte) cnt#9 ← phi( @begin/(byte) cnt#6 )
(byte) cnt#1 ← (byte) cnt#9
to:@end
main: scope:[main] from @begin
(byte[256]) SCREEN#3 ← phi( @begin/(word) 1024 )
(byte) cnt#15 ← phi( @begin/(byte) 0 )
call inccnt param-assignment
to:main::@1
main::@1: scope:[main] from main
(byte[256]) SCREEN#1 ← phi( main/(byte[256]) SCREEN#3 )
(byte) cnt#10 ← phi( main/(byte) cnt#8 )
(byte) cnt#2 ← (byte) cnt#10
*((byte[256]) SCREEN#1 + (byte) 0) ← (byte) cnt#2
(byte) cnt#3 ← ++ (byte) cnt#2
call inccnt param-assignment
to:main::@2
main::@2: scope:[main] from main::@1
(byte[256]) SCREEN#2 ← phi( main::@1/(byte[256]) SCREEN#1 )
(byte) cnt#11 ← phi( main::@1/(byte) cnt#8 )
(byte) cnt#4 ← (byte) cnt#11
(byte) cnt#5 ← ++ (byte) cnt#4
*((byte[256]) SCREEN#2 + (byte) 1) ← (byte) cnt#5
to:main::@return
main::@return: scope:[main] from main::@2
(byte) cnt#12 ← phi( main::@2/(byte) cnt#5 )
(byte) cnt#6 ← (byte) cnt#12
return
to:@return
inccnt: scope:[inccnt] from main main::@1
(byte) cnt#13 ← phi( main/(byte) cnt#15 main::@1/(byte) cnt#3 )
(byte) cnt#7 ← ++ (byte) cnt#13
to:inccnt::@return
inccnt::@return: scope:[inccnt] from inccnt
(byte) cnt#14 ← phi( inccnt/(byte) cnt#7 )
(byte) cnt#8 ← (byte) cnt#14
return
to:@return
@end: scope:[] from @3
Alias (byte) cnt#1 = (byte) cnt#9 (byte) cnt#6 (byte) cnt#12 (byte) cnt#5
Alias (byte) cnt#0 = (byte) cnt#15
Alias (byte[256]) SCREEN#0 = (byte[256]) SCREEN#3 (byte[256]) SCREEN#1 (byte[256]) SCREEN#2
Alias (byte) cnt#10 = (byte) cnt#8 (byte) cnt#2 (byte) cnt#11 (byte) cnt#4 (byte) cnt#14 (byte) cnt#7
Alias (byte[256]) SCREEN#1 = (byte[256]) SCREEN#3 (byte[256]) SCREEN#2
Succesful SSA optimization Pass2AliasElimination
CONTROL FLOW GRAPH
@begin: scope:[] from
(byte) cnt#0 ← (byte) 0
(byte[256]) SCREEN#0 ← (word) 1024
call main param-assignment
to:@3
@3: scope:[] from @begin
to:@end
main: scope:[main] from @begin
(byte[256]) SCREEN#1 ← phi( @begin/(word) 1024 )
(byte) cnt#15 ← phi( @begin/(byte) 0 )
call inccnt param-assignment
to:main::@1
main::@1: scope:[main] from main
*((byte[256]) SCREEN#1 + (byte) 0) ← (byte) cnt#10
*((byte[256]) SCREEN#0 + (byte) 0) ← (byte) cnt#10
(byte) cnt#3 ← ++ (byte) cnt#10
call inccnt param-assignment
to:main::@2
main::@2: scope:[main] from main::@1
(byte) cnt#1 ← ++ (byte) cnt#10
*((byte[256]) SCREEN#1 + (byte) 1) ← (byte) cnt#1
*((byte[256]) SCREEN#0 + (byte) 1) ← (byte) cnt#1
to:main::@return
main::@return: scope:[main] from main::@2
return
to:@return
inccnt: scope:[inccnt] from main main::@1
(byte) cnt#13 ← phi( main/(byte) cnt#15 main::@1/(byte) cnt#3 )
(byte) cnt#13 ← phi( main/(byte) cnt#0 main::@1/(byte) cnt#3 )
(byte) cnt#10 ← ++ (byte) cnt#13
to:inccnt::@return
inccnt::@return: scope:[inccnt] from inccnt
@ -357,9 +311,9 @@ inccnt::@return: scope:[inccnt] from inccnt
to:@return
@end: scope:[] from @3
Redundant Phi (byte) cnt#15 (byte) 0
Redundant Phi (byte[256]) SCREEN#1 (word) 1024
Succesful SSA optimization Pass2RedundantPhiElimination
Constant (const byte) cnt#0 = 0
Constant (const byte[256]) SCREEN#0 = 1024
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
@ -370,19 +324,52 @@ main: scope:[main] from @begin
call inccnt param-assignment
to:main::@1
main::@1: scope:[main] from main
*((word) 1024 + (byte) 0) ← (byte) cnt#10
*((const byte[256]) SCREEN#0 + (byte) 0) ← (byte) cnt#10
(byte) cnt#3 ← ++ (byte) cnt#10
call inccnt param-assignment
to:main::@2
main::@2: scope:[main] from main::@1
(byte) cnt#1 ← ++ (byte) cnt#10
*((word) 1024 + (byte) 1) ← (byte) cnt#1
*((const byte[256]) SCREEN#0 + (byte) 1) ← (byte) cnt#1
to:main::@return
main::@return: scope:[main] from main::@2
return
to:@return
inccnt: scope:[inccnt] from main main::@1
(byte) cnt#13 ← phi( main/(byte) 0 main::@1/(byte) cnt#3 )
(byte) cnt#13 ← phi( main/(const byte) cnt#0 main::@1/(byte) cnt#3 )
(byte) cnt#10 ← ++ (byte) cnt#13
to:inccnt::@return
inccnt::@return: scope:[inccnt] from inccnt
return
to:@return
@end: scope:[] from @3
Consolidated assigned array index constant in assignment *(SCREEN#0+0)
Consolidated assigned array index constant in assignment *(SCREEN#0+1)
Succesful SSA optimization Pass2ConstantAdditionElimination
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
to:@3
@3: scope:[] from @begin
to:@end
main: scope:[main] from @begin
call inccnt param-assignment
to:main::@1
main::@1: scope:[main] from main
*((const byte[256]) SCREEN#0+(byte) 0) ← (byte) cnt#10
(byte) cnt#3 ← ++ (byte) cnt#10
call inccnt param-assignment
to:main::@2
main::@2: scope:[main] from main::@1
(byte) cnt#1 ← ++ (byte) cnt#10
*((const byte[256]) SCREEN#0+(byte) 1) ← (byte) cnt#1
to:main::@return
main::@return: scope:[main] from main::@2
return
to:@return
inccnt: scope:[inccnt] from main main::@1
(byte) cnt#13 ← phi( main/(const byte) cnt#0 main::@1/(byte) cnt#3 )
(byte) cnt#10 ← ++ (byte) cnt#13
to:inccnt::@return
inccnt::@return: scope:[inccnt] from inccnt
@ -400,19 +387,19 @@ main: scope:[main] from @begin
call inccnt param-assignment
to:main::@1
main::@1: scope:[main] from main
*((word) 1024 + (byte) 0) ← (byte) cnt#10
*((const byte[256]) SCREEN#0+(byte) 0) ← (byte) cnt#10
(byte) cnt#3 ← ++ (byte) cnt#10
call inccnt param-assignment
to:main::@2
main::@2: scope:[main] from main::@1
(byte) cnt#1 ← ++ (byte) cnt#10
*((word) 1024 + (byte) 1) ← (byte) cnt#1
*((const byte[256]) SCREEN#0+(byte) 1) ← (byte) cnt#1
to:main::@return
main::@return: scope:[main] from main::@2
return
to:@return
inccnt: scope:[inccnt] from main main::@1
(byte) cnt#13 ← phi( main/(byte) 0 main::@1/(byte) cnt#3 )
(byte) cnt#13 ← phi( main/(const byte) cnt#0 main::@1/(byte) cnt#3 )
(byte) cnt#10 ← ++ (byte) cnt#13
to:inccnt::@return
inccnt::@return: scope:[inccnt] from inccnt
@ -420,9 +407,8 @@ inccnt::@return: scope:[inccnt] from inccnt
to:@return
@end: scope:[] from @begin
Consolidated assigned array index constant in assignment *(1024)
Consolidated assigned array index constant in assignment *(1025)
Succesful SSA optimization Pass2ConstantAdditionElimination
Constant inlined cnt#0 = (byte) 0
Succesful SSA optimization Pass2ConstantInlining
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
@ -431,13 +417,13 @@ main: scope:[main] from @begin
call inccnt param-assignment
to:main::@1
main::@1: scope:[main] from main
*((word) 1024) ← (byte) cnt#10
*((const byte[256]) SCREEN#0+(byte) 0) ← (byte) cnt#10
(byte) cnt#3 ← ++ (byte) cnt#10
call inccnt param-assignment
to:main::@2
main::@2: scope:[main] from main::@1
(byte) cnt#1 ← ++ (byte) cnt#10
*((word) 1025) ← (byte) cnt#1
*((const byte[256]) SCREEN#0+(byte) 1) ← (byte) cnt#1
to:main::@return
main::@return: scope:[main] from main::@2
return
@ -455,6 +441,7 @@ FINAL SYMBOL TABLE
(label) @begin
(label) @end
(byte[256]) SCREEN
(const byte[256]) SCREEN#0 = (word) 1024
(byte) cnt
(byte) cnt#1
(byte) cnt#10
@ -478,14 +465,14 @@ main: scope:[main] from @begin
call inccnt param-assignment
to:main::@1
main::@1: scope:[main] from main
*((word) 1024) ← (byte) cnt#10
*((const byte[256]) SCREEN#0+(byte) 0) ← (byte) cnt#10
(byte) cnt#3 ← ++ (byte) cnt#10
(byte~) cnt#16 ← (byte) cnt#3
call inccnt param-assignment
to:main::@2
main::@2: scope:[main] from main::@1
(byte) cnt#1 ← ++ (byte) cnt#10
*((word) 1025) ← (byte) cnt#1
*((const byte[256]) SCREEN#0+(byte) 1) ← (byte) cnt#1
to:main::@return
main::@return: scope:[main] from main::@2
return
@ -516,14 +503,14 @@ main: scope:[main] from @begin
[2] call inccnt param-assignment [ cnt#10 ]
to:main::@1
main::@1: scope:[main] from main
[3] *((word) 1024) ← (byte) cnt#10 [ cnt#10 ]
[3] *((const byte[256]) SCREEN#0+(byte) 0) ← (byte) cnt#10 [ cnt#10 ]
[4] (byte) cnt#3 ← ++ (byte) cnt#10 [ cnt#3 ]
[5] (byte~) cnt#16 ← (byte) cnt#3 [ cnt#16 ]
[6] call inccnt param-assignment [ cnt#10 ]
to:main::@2
main::@2: scope:[main] from main::@1
[7] (byte) cnt#1 ← ++ (byte) cnt#10 [ cnt#1 ]
[8] *((word) 1025) ← (byte) cnt#1 [ ]
[8] *((const byte[256]) SCREEN#0+(byte) 1) ← (byte) cnt#1 [ ]
to:main::@return
main::@return: scope:[main] from main::@2
[9] return [ ]
@ -554,13 +541,13 @@ main: scope:[main] from @begin
[2] call inccnt param-assignment [ cnt#10 ]
to:main::@1
main::@1: scope:[main] from main
[3] *((word) 1024) ← (byte) cnt#10 [ cnt#10 ]
[3] *((const byte[256]) SCREEN#0+(byte) 0) ← (byte) cnt#10 [ cnt#10 ]
[4] (byte) cnt#3 ← ++ (byte) cnt#10 [ cnt#3 ]
[5] call inccnt param-assignment [ cnt#10 ]
to:main::@2
main::@2: scope:[main] from main::@1
[6] (byte) cnt#1 ← ++ (byte) cnt#10 [ cnt#1 ]
[7] *((word) 1025) ← (byte) cnt#1 [ ]
[7] *((const byte[256]) SCREEN#0+(byte) 1) ← (byte) cnt#1 [ ]
to:main::@return
main::@return: scope:[main] from main::@2
[8] return [ ]
@ -613,7 +600,8 @@ Allocated zp ZP_BYTE:2 [ cnt#13 cnt#3 ]
Allocated zp ZP_BYTE:3 [ cnt#1 ]
Allocated zp ZP_BYTE:4 [ cnt#10 ]
INITIAL ASM
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const SCREEN = $400
.label cnt = 3
.label cnt_3 = 2
.label cnt_10 = 4
@ -639,9 +627,9 @@ main: {
jmp b1
//SEG9 main::@1
b1:
//SEG10 [3] *((word) 1024) ← (byte) cnt#10 [ cnt#10 ] -- _star_cowo1=zpby1
//SEG10 [3] *((const byte[256]) SCREEN#0+(byte) 0) ← (byte) cnt#10 [ cnt#10 ] -- _star_cowo1=zpby1
lda cnt_10
sta $400
sta SCREEN+$0
//SEG11 [4] (byte) cnt#3 ← ++ (byte) cnt#10 [ cnt#3 ] -- zpby1=_inc_zpby2
lda cnt_10
sta cnt_3
@ -658,9 +646,9 @@ main: {
lda cnt_10
sta cnt
inc cnt
//SEG17 [7] *((word) 1025) ← (byte) cnt#1 [ ] -- _star_cowo1=zpby1
//SEG17 [7] *((const byte[256]) SCREEN#0+(byte) 1) ← (byte) cnt#1 [ ] -- _star_cowo1=zpby1
lda cnt
sta $401
sta SCREEN+$1
jmp breturn
//SEG18 main::@return
breturn:
@ -700,7 +688,8 @@ Removing instruction jmp breturn
Removing instruction jmp breturn
Succesful ASM optimization Pass5NextJumpElimination
ASSEMBLER
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const SCREEN = $400
//SEG1 @begin
bbegin:
//SEG2 [0] call main param-assignment [ ]
@ -719,8 +708,8 @@ main: {
jsr inccnt
//SEG9 main::@1
b1:
//SEG10 [3] *((word) 1024) ← (byte) cnt#10 [ cnt#10 ] -- _star_cowo1=xby
stx $400
//SEG10 [3] *((const byte[256]) SCREEN#0+(byte) 0) ← (byte) cnt#10 [ cnt#10 ] -- _star_cowo1=xby
stx SCREEN+$0
//SEG11 [4] (byte) cnt#3 ← ++ (byte) cnt#10 [ cnt#3 ] -- xby=_inc_xby
inx
//SEG12 [5] call inccnt param-assignment [ cnt#10 ]
@ -732,8 +721,8 @@ main: {
b2:
//SEG16 [6] (byte) cnt#1 ← ++ (byte) cnt#10 [ cnt#1 ] -- xby=_inc_xby
inx
//SEG17 [7] *((word) 1025) ← (byte) cnt#1 [ ] -- _star_cowo1=xby
stx $401
//SEG17 [7] *((const byte[256]) SCREEN#0+(byte) 1) ← (byte) cnt#1 [ ] -- _star_cowo1=xby
stx SCREEN+$1
//SEG18 main::@return
breturn:
//SEG19 [8] return [ ]
@ -752,7 +741,8 @@ inccnt: {
Removing instruction main_from_bbegin:
Succesful ASM optimization Pass5RedundantLabelElimination
ASSEMBLER
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const SCREEN = $400
//SEG1 @begin
bbegin:
//SEG2 [0] call main param-assignment [ ]
@ -770,8 +760,8 @@ main: {
jsr inccnt
//SEG9 main::@1
b1:
//SEG10 [3] *((word) 1024) ← (byte) cnt#10 [ cnt#10 ] -- _star_cowo1=xby
stx $400
//SEG10 [3] *((const byte[256]) SCREEN#0+(byte) 0) ← (byte) cnt#10 [ cnt#10 ] -- _star_cowo1=xby
stx SCREEN+$0
//SEG11 [4] (byte) cnt#3 ← ++ (byte) cnt#10 [ cnt#3 ] -- xby=_inc_xby
inx
//SEG12 [5] call inccnt param-assignment [ cnt#10 ]
@ -783,8 +773,8 @@ main: {
b2:
//SEG16 [6] (byte) cnt#1 ← ++ (byte) cnt#10 [ cnt#1 ] -- xby=_inc_xby
inx
//SEG17 [7] *((word) 1025) ← (byte) cnt#1 [ ] -- _star_cowo1=xby
stx $401
//SEG17 [7] *((const byte[256]) SCREEN#0+(byte) 1) ← (byte) cnt#1 [ ] -- _star_cowo1=xby
stx SCREEN+$1
//SEG18 main::@return
breturn:
//SEG19 [8] return [ ]
@ -810,7 +800,8 @@ Removing instruction breturn:
Removing instruction breturn:
Succesful ASM optimization Pass5UnusedLabelElimination
ASSEMBLER
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const SCREEN = $400
//SEG1 @begin
//SEG2 [0] call main param-assignment [ ]
//SEG3 [1] phi from @begin to main
@ -824,8 +815,8 @@ main: {
ldx #$0
jsr inccnt
//SEG9 main::@1
//SEG10 [3] *((word) 1024) ← (byte) cnt#10 [ cnt#10 ] -- _star_cowo1=xby
stx $400
//SEG10 [3] *((const byte[256]) SCREEN#0+(byte) 0) ← (byte) cnt#10 [ cnt#10 ] -- _star_cowo1=xby
stx SCREEN+$0
//SEG11 [4] (byte) cnt#3 ← ++ (byte) cnt#10 [ cnt#3 ] -- xby=_inc_xby
inx
//SEG12 [5] call inccnt param-assignment [ cnt#10 ]
@ -835,8 +826,8 @@ main: {
//SEG15 main::@2
//SEG16 [6] (byte) cnt#1 ← ++ (byte) cnt#10 [ cnt#1 ] -- xby=_inc_xby
inx
//SEG17 [7] *((word) 1025) ← (byte) cnt#1 [ ] -- _star_cowo1=xby
stx $401
//SEG17 [7] *((const byte[256]) SCREEN#0+(byte) 1) ← (byte) cnt#1 [ ] -- _star_cowo1=xby
stx SCREEN+$1
//SEG18 main::@return
//SEG19 [8] return [ ]
rts
@ -854,6 +845,7 @@ FINAL SYMBOL TABLE
(label) @begin
(label) @end
(byte[256]) SCREEN
(const byte[256]) SCREEN#0 = (word) 1024
(byte) cnt
(byte) cnt#1 reg byte x 4.0
(byte) cnt#10 reg byte x 1.6
@ -871,7 +863,8 @@ reg byte x [ cnt#1 ]
reg byte x [ cnt#10 ]
FINAL CODE
//SEG0 Global ZP labels
//SEG0 Global Constants & labels
.const SCREEN = $400
//SEG1 @begin
//SEG2 [0] call main param-assignment [ ]
//SEG3 [1] phi from @begin to main
@ -885,8 +878,8 @@ main: {
ldx #$0
jsr inccnt
//SEG9 main::@1
//SEG10 [3] *((word) 1024) ← (byte) cnt#10 [ cnt#10 ] -- _star_cowo1=xby
stx $400
//SEG10 [3] *((const byte[256]) SCREEN#0+(byte) 0) ← (byte) cnt#10 [ cnt#10 ] -- _star_cowo1=xby
stx SCREEN+$0
//SEG11 [4] (byte) cnt#3 ← ++ (byte) cnt#10 [ cnt#3 ] -- xby=_inc_xby
inx
//SEG12 [5] call inccnt param-assignment [ cnt#10 ]
@ -896,8 +889,8 @@ main: {
//SEG15 main::@2
//SEG16 [6] (byte) cnt#1 ← ++ (byte) cnt#10 [ cnt#1 ] -- xby=_inc_xby
inx
//SEG17 [7] *((word) 1025) ← (byte) cnt#1 [ ] -- _star_cowo1=xby
stx $401
//SEG17 [7] *((const byte[256]) SCREEN#0+(byte) 1) ← (byte) cnt#1 [ ] -- _star_cowo1=xby
stx SCREEN+$1
//SEG18 main::@return
//SEG19 [8] return [ ]
rts

1
src/main/java/dk/camelot64/kickc/test/ref/modglobalmin.sym
View File

@ -1,6 +1,7 @@
(label) @begin
(label) @end
(byte[256]) SCREEN
(const byte[256]) SCREEN#0 = (word) 1024
(byte) cnt
(byte) cnt#1 reg byte x 4.0
(byte) cnt#10 reg byte x 1.6

17
src/main/java/dk/camelot64/kickc/test/ref/ptrtest.asm
View File

@ -7,6 +7,7 @@ main: {
rts
}
lvaluevar: {
.const b = $4
.label screen = 2
lda #<$400
sta screen
@ -19,7 +20,7 @@ lvaluevar: {
rts
b2:
ldy #$0
lda #$4
lda #b
sta (screen),y
inc screen
bne !+
@ -50,23 +51,25 @@ rvaluevar: {
jmp b1
}
rvalue: {
lda $400
lda $401
.const SCREEN = $400
lda SCREEN
lda SCREEN+$1
ldx #$2
b1:
cpx #$a
bcc b2
rts
b2:
lda $400,x
lda SCREEN,x
inx
jmp b1
}
lvalue: {
.const SCREEN = $400
lda #$1
sta $400
sta SCREEN
lda #$2
sta $401
sta SCREEN+$1
ldx #$2
b1:
cpx #$a
@ -74,7 +77,7 @@ lvalue: {
rts
b2:
lda #$3
sta $400,x
sta SCREEN,x
inx
jmp b1
}

14
src/main/java/dk/camelot64/kickc/test/ref/ptrtest.cfg
View File

@ -30,7 +30,7 @@ lvaluevar::@return: scope:[lvaluevar] from lvaluevar::@1
[10] return [ ]
to:@return
lvaluevar::@2: scope:[lvaluevar] from lvaluevar::@1
[11] *((byte*) lvaluevar::screen#2) ← (byte) 4 [ lvaluevar::i#2 lvaluevar::screen#2 ]
[11] *((byte*) lvaluevar::screen#2) ← (const byte) lvaluevar::b#0 [ lvaluevar::i#2 lvaluevar::screen#2 ]
[12] (byte*) lvaluevar::screen#1 ← ++ (byte*) lvaluevar::screen#2 [ lvaluevar::i#2 lvaluevar::screen#1 ]
[13] (byte) lvaluevar::i#1 ← ++ (byte) lvaluevar::i#2 [ lvaluevar::i#1 lvaluevar::screen#1 ]
to:lvaluevar::@1
@ -51,8 +51,8 @@ rvaluevar::@2: scope:[rvaluevar] from rvaluevar::@1
[20] (byte) rvaluevar::i#1 ← ++ (byte) rvaluevar::i#2 [ rvaluevar::i#1 rvaluevar::screen#1 ]
to:rvaluevar::@1
rvalue: scope:[rvalue] from main::@1
[21] (byte) rvalue::b#0 ← * (word) 1024 [ ]
[22] (byte) rvalue::b#1 ← * (word) 1025 [ ]
[21] (byte) rvalue::b#0 ← * (const byte[1024]) rvalue::SCREEN#0 [ ]
[22] (byte) rvalue::b#1 ← * (const byte[1024]) rvalue::SCREEN#0+(byte) 1 [ ]
to:rvalue::@1
rvalue::@1: scope:[rvalue] from rvalue rvalue::@2
[23] (byte) rvalue::i#2 ← phi( rvalue/(byte) 2 rvalue::@2/(byte) rvalue::i#1 ) [ rvalue::i#2 ]
@ -62,12 +62,12 @@ rvalue::@return: scope:[rvalue] from rvalue::@1
[25] return [ ]
to:@return
rvalue::@2: scope:[rvalue] from rvalue::@1
[26] (byte) rvalue::b#2 ← (word) 1024 *idx (byte) rvalue::i#2 [ rvalue::i#2 ]
[26] (byte) rvalue::b#2 ← (const byte[1024]) rvalue::SCREEN#0 *idx (byte) rvalue::i#2 [ rvalue::i#2 ]
[27] (byte) rvalue::i#1 ← ++ (byte) rvalue::i#2 [ rvalue::i#1 ]
to:rvalue::@1
lvalue: scope:[lvalue] from main
[28] *((word) 1024) ← (byte) 1 [ ]
[29] *((word) 1025) ← (byte) 2 [ ]
[28] *((const byte[1024]) lvalue::SCREEN#0) ← (byte) 1 [ ]
[29] *((const byte[1024]) lvalue::SCREEN#0+(byte) 1) ← (byte) 2 [ ]
to:lvalue::@1
lvalue::@1: scope:[lvalue] from lvalue lvalue::@2
[30] (byte) lvalue::i#2 ← phi( lvalue/(byte) 2 lvalue::@2/(byte) lvalue::i#1 ) [ lvalue::i#2 ]
@ -77,6 +77,6 @@ lvalue::@return: scope:[lvalue] from lvalue::@1
[32] return [ ]
to:@return
lvalue::@2: scope:[lvalue] from lvalue::@1
[33] *((word) 1024 + (byte) lvalue::i#2) ← (byte) 3 [ lvalue::i#2 ]
[33] *((const byte[1024]) lvalue::SCREEN#0 + (byte) lvalue::i#2) ← (byte) 3 [ lvalue::i#2 ]
[34] (byte) lvalue::i#1 ← ++ (byte) lvalue::i#2 [ lvalue::i#1 ]
to:lvalue::@1

847
src/main/java/dk/camelot64/kickc/test/ref/ptrtest.log
View File

File diff suppressed because it is too large Load Diff

3
src/main/java/dk/camelot64/kickc/test/ref/ptrtest.sym
View File

@ -5,6 +5,7 @@
(label) lvalue::@2
(label) lvalue::@return
(byte[1024]) lvalue::SCREEN
(const byte[1024]) lvalue::SCREEN#0 = (word) 1024
(byte) lvalue::i
(byte) lvalue::i#1 reg byte x 22.0
(byte) lvalue::i#2 reg byte x 14.666666666666666
@ -13,6 +14,7 @@
(label) lvaluevar::@2
(label) lvaluevar::@return
(byte) lvaluevar::b
(const byte) lvaluevar::b#0 = (byte) 4
(byte) lvaluevar::i
(byte) lvaluevar::i#1 reg byte x 22.0
(byte) lvaluevar::i#2 reg byte x 8.25
@ -29,6 +31,7 @@
(label) rvalue::@2
(label) rvalue::@return
(byte[1024]) rvalue::SCREEN
(const byte[1024]) rvalue::SCREEN#0 = (word) 1024
(byte) rvalue::b
(byte) rvalue::b#0 reg byte a 20.0
(byte) rvalue::b#1 reg byte a 20.0

13
src/main/java/dk/camelot64/kickc/test/ref/ptrtestmin.log
View File

@ -319,8 +319,8 @@ main::@return: scope:[main] from main::@1
to:@return
@end: scope:[] from @begin
Constant (const byte[1024]) main::SCREEN#0
Constant (const byte) main::i#0
Constant (const byte[1024]) main::SCREEN#0 = 1024
Constant (const byte) main::i#0 = 2
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
@ -342,8 +342,8 @@ main::@return: scope:[main] from main::@1
to:@return
@end: scope:[] from @begin
Redundant Phi (byte[1024]) main::SCREEN#1 (const byte[1024]) main::SCREEN#0
Succesful SSA optimization Pass2RedundantPhiElimination
Constant (const byte[1024]) main::SCREEN#1 = main::SCREEN#0
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
@ -355,7 +355,7 @@ main::@1: scope:[main] from main main::@2
if((byte) main::i#2<(byte) 10) goto main::@2
to:main::@return
main::@2: scope:[main] from main::@1
(byte) main::b#0 ← (const byte[1024]) main::SCREEN#0 *idx (byte) main::i#2
(byte) main::b#0 ← (const byte[1024]) main::SCREEN#1 *idx (byte) main::i#2
(byte) main::i#1 ← ++ (byte) main::i#2
to:main::@1
main::@return: scope:[main] from main::@1
@ -363,6 +363,9 @@ main::@return: scope:[main] from main::@1
to:@return
@end: scope:[] 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
Constant inlined main::SCREEN#1 = (const byte[1024]) main::SCREEN#0
Constant inlined main::i#0 = (byte) 2
Succesful SSA optimization Pass2ConstantInlining
CONTROL FLOW GRAPH

15
src/main/java/dk/camelot64/kickc/test/ref/summin.log
View File

@ -316,12 +316,15 @@ sum::@return: scope:[sum] from sum
to:@return
@end: scope:[] from @4
Constant (const byte) sum::a#0
Constant (const byte) sum::b#0
Constant (const byte) sum::a#1
Constant (const byte) sum::b#1
Constant (const byte) sum::a#2
Constant (const byte) sum::b#2
Not aliassing across scopes: s1#0 sum::return#0
Not aliassing across scopes: s2#0 sum::return#0
Not aliassing across scopes: s3#0 sum::return#0
Constant (const byte) sum::a#0 = 1
Constant (const byte) sum::b#0 = 2
Constant (const byte) sum::a#1 = 3
Constant (const byte) sum::b#1 = 4
Constant (const byte) sum::a#2 = 9
Constant (const byte) sum::b#2 = 13
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from

2
src/main/java/dk/camelot64/kickc/test/ref/useglobal.log
View File

@ -139,7 +139,7 @@ main::@return: scope:[main] from main
to:@return
@end: scope:[] from @begin
Constant (const byte*) SCREEN#0
Constant (const byte*) SCREEN#0 = 1024
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from

82
src/main/java/dk/camelot64/kickc/test/ref/voronoi.asm
View File

@ -1,3 +1,9 @@
.const SCREEN = $400
.const COLORS = $d800
.const FILL = $e6
.const XPOS = $1000
.const YPOS = $1100
.const COLS = $1200
.label numpoints = 8
jsr main
main: {
@ -41,64 +47,64 @@ main: {
rts
}
animate: {
lda $1000
lda XPOS+$0
clc
adc #$1
sta $1000
lda $1000
sta XPOS+$0
lda XPOS+$0
cmp #$28
bne b1
lda #$0
sta $1000
sta XPOS+$0
b1:
lda $1100
lda YPOS+$0
clc
adc #$1
sta $1100
lda $1100
sta YPOS+$0
lda YPOS+$0
cmp #$19
bne b2
lda #$0
sta $1100
sta YPOS+$0
b2:
ldx $1001
ldx XPOS+$1
dex
stx $1001
lda $1001
stx XPOS+$1
lda XPOS+$1
cmp #$ff
bne b3
lda #$28
sta $1001
sta XPOS+$1
b3:
lda $1102
lda YPOS+$2
clc
adc #$1
sta $1102
lda $1102
sta YPOS+$2
lda YPOS+$2
cmp #$19
bne b4
lda #$0
sta $1102
sta YPOS+$2
b4:
ldx $1103
ldx YPOS+$3
dex
stx $1103
lda $1103
stx YPOS+$3
lda YPOS+$3
cmp #$ff
bne breturn
lda #$19
sta $1103
lda $1003
sta YPOS+$3
lda XPOS+$3
clc
adc #$7
sta $1003
lda $1003
sta XPOS+$3
lda XPOS+$3
cmp #$28
bcc breturn
lda $1003
lda XPOS+$3
sec
sbc #$28
sta $1003
sta XPOS+$3
breturn:
rts
}
@ -106,9 +112,9 @@ render: {
.label x = 5
.label colline = 3
.label y = 2
lda #<$d800
lda #<COLORS
sta colline
lda #>$d800
lda #>COLORS
sta colline+$1
lda #$0
sta y
@ -153,9 +159,9 @@ findcol: {
sta mindiff
ldx #$0
b1:
lda $1000,x
lda XPOS,x
sta xp
lda $1100,x
lda YPOS,x
sta yp
lda x
cmp xp
@ -186,7 +192,7 @@ findcol: {
b7:
cmp mindiff
bcs b21
ldy $1200,x
ldy COLS,x
b8:
inx
cpx numpoints
@ -214,24 +220,24 @@ findcol: {
}
initscreen: {
.label screen = 3
lda #<$400
lda #<SCREEN
sta screen
lda #>$400
lda #>SCREEN
sta screen+$1
b1:
ldy #$0
lda #$e6
lda #FILL
sta (screen),y
inc screen
bne !+
inc screen+$1
!:
lda screen+$1
cmp #>$7e8
cmp #>SCREEN+$3e8
bcc b1
bne !+
lda screen
cmp #<$7e8
cmp #<SCREEN+$3e8
bcc b1
!:
rts
@ -239,13 +245,13 @@ initscreen: {
addpoint: {
.label c = 2
ldx numpoints
sta $1000,x
sta XPOS,x
tya
ldy numpoints
sta $1100,y
sta YPOS,y
lda c
ldx numpoints
sta $1200,x
sta COLS,x
inc numpoints
rts
}

70
src/main/java/dk/camelot64/kickc/test/ref/voronoi.cfg
View File

@ -37,64 +37,64 @@ main::@return: scope:[main] from main::@11
[12] return [ ]
to:@return
animate: scope:[animate] from main::@10
[13] (byte~) animate::$0 ← * (word) 4096 [ animate::$0 ]
[13] (byte~) animate::$0 ← * (const byte[256]) XPOS#0+(byte) 0 [ animate::$0 ]
[14] (byte~) animate::$1 ← (byte~) animate::$0 + (byte) 1 [ animate::$1 ]
[15] *((word) 4096) ← (byte~) animate::$1 [ ]
[16] (byte~) animate::$2 ← * (word) 4096 [ animate::$2 ]
[15] *((const byte[256]) XPOS#0+(byte) 0) ← (byte~) animate::$1 [ ]
[16] (byte~) animate::$2 ← * (const byte[256]) XPOS#0+(byte) 0 [ animate::$2 ]
[17] if((byte~) animate::$2!=(byte) 40) goto animate::@1 [ ]
to:animate::@7
animate::@7: scope:[animate] from animate
[18] *((word) 4096) ← (byte) 0 [ ]
[18] *((const byte[256]) XPOS#0+(byte) 0) ← (byte) 0 [ ]
to:animate::@1
animate::@1: scope:[animate] from animate animate::@7
[19] (byte~) animate::$5 ← * (word) 4352 [ animate::$5 ]
[19] (byte~) animate::$5 ← * (const byte[256]) YPOS#0+(byte) 0 [ animate::$5 ]
[20] (byte~) animate::$6 ← (byte~) animate::$5 + (byte) 1 [ animate::$6 ]
[21] *((word) 4352) ← (byte~) animate::$6 [ ]
[22] (byte~) animate::$7 ← * (word) 4352 [ animate::$7 ]
[21] *((const byte[256]) YPOS#0+(byte) 0) ← (byte~) animate::$6 [ ]
[22] (byte~) animate::$7 ← * (const byte[256]) YPOS#0+(byte) 0 [ animate::$7 ]
[23] if((byte~) animate::$7!=(byte) 25) goto animate::@2 [ ]
to:animate::@8
animate::@8: scope:[animate] from animate::@1
[24] *((word) 4352) ← (byte) 0 [ ]
[24] *((const byte[256]) YPOS#0+(byte) 0) ← (byte) 0 [ ]
to:animate::@2
animate::@2: scope:[animate] from animate::@1 animate::@8
[25] (byte~) animate::$10 ← * (word) 4097 [ animate::$10 ]
[25] (byte~) animate::$10 ← * (const byte[256]) XPOS#0+(byte) 1 [ animate::$10 ]
[26] (byte~) animate::$11 ← (byte~) animate::$10 - (byte) 1 [ animate::$11 ]
[27] *((word) 4097) ← (byte~) animate::$11 [ ]
[28] (byte~) animate::$12 ← * (word) 4097 [ animate::$12 ]
[27] *((const byte[256]) XPOS#0+(byte) 1) ← (byte~) animate::$11 [ ]
[28] (byte~) animate::$12 ← * (const byte[256]) XPOS#0+(byte) 1 [ animate::$12 ]
[29] if((byte~) animate::$12!=(byte) 255) goto animate::@3 [ ]
to:animate::@9
animate::@9: scope:[animate] from animate::@2
[30] *((word) 4097) ← (byte) 40 [ ]
[30] *((const byte[256]) XPOS#0+(byte) 1) ← (byte) 40 [ ]
to:animate::@3
animate::@3: scope:[animate] from animate::@2 animate::@9
[31] (byte~) animate::$15 ← * (word) 4354 [ animate::$15 ]
[31] (byte~) animate::$15 ← * (const byte[256]) YPOS#0+(byte) 2 [ animate::$15 ]
[32] (byte~) animate::$16 ← (byte~) animate::$15 + (byte) 1 [ animate::$16 ]
[33] *((word) 4354) ← (byte~) animate::$16 [ ]
[34] (byte~) animate::$17 ← * (word) 4354 [ animate::$17 ]
[33] *((const byte[256]) YPOS#0+(byte) 2) ← (byte~) animate::$16 [ ]
[34] (byte~) animate::$17 ← * (const byte[256]) YPOS#0+(byte) 2 [ animate::$17 ]
[35] if((byte~) animate::$17!=(byte) 25) goto animate::@4 [ ]
to:animate::@10
animate::@10: scope:[animate] from animate::@3
[36] *((word) 4354) ← (byte) 0 [ ]
[36] *((const byte[256]) YPOS#0+(byte) 2) ← (byte) 0 [ ]
to:animate::@4
animate::@4: scope:[animate] from animate::@10 animate::@3
[37] (byte~) animate::$20 ← * (word) 4355 [ animate::$20 ]
[37] (byte~) animate::$20 ← * (const byte[256]) YPOS#0+(byte) 3 [ animate::$20 ]
[38] (byte~) animate::$21 ← (byte~) animate::$20 - (byte) 1 [ animate::$21 ]
[39] *((word) 4355) ← (byte~) animate::$21 [ ]
[40] (byte~) animate::$22 ← * (word) 4355 [ animate::$22 ]
[39] *((const byte[256]) YPOS#0+(byte) 3) ← (byte~) animate::$21 [ ]
[40] (byte~) animate::$22 ← * (const byte[256]) YPOS#0+(byte) 3 [ animate::$22 ]
[41] if((byte~) animate::$22!=(byte) 255) goto animate::@return [ ]
to:animate::@11
animate::@11: scope:[animate] from animate::@4
[42] *((word) 4355) ← (byte) 25 [ ]
[43] (byte~) animate::$25 ← * (word) 4099 [ animate::$25 ]
[42] *((const byte[256]) YPOS#0+(byte) 3) ← (byte) 25 [ ]
[43] (byte~) animate::$25 ← * (const byte[256]) XPOS#0+(byte) 3 [ animate::$25 ]
[44] (byte~) animate::$26 ← (byte~) animate::$25 + (byte) 7 [ animate::$26 ]
[45] *((word) 4099) ← (byte~) animate::$26 [ ]
[46] (byte~) animate::$27 ← * (word) 4099 [ animate::$27 ]
[45] *((const byte[256]) XPOS#0+(byte) 3) ← (byte~) animate::$26 [ ]
[46] (byte~) animate::$27 ← * (const byte[256]) XPOS#0+(byte) 3 [ animate::$27 ]
[47] if((byte~) animate::$27<(byte) 40) goto animate::@return [ ]
to:animate::@12
animate::@12: scope:[animate] from animate::@11
[48] (byte~) animate::$30 ← * (word) 4099 [ animate::$30 ]
[48] (byte~) animate::$30 ← * (const byte[256]) XPOS#0+(byte) 3 [ animate::$30 ]
[49] (byte~) animate::$31 ← (byte~) animate::$30 - (byte) 40 [ animate::$31 ]
[50] *((word) 4099) ← (byte~) animate::$31 [ ]
[50] *((const byte[256]) XPOS#0+(byte) 3) ← (byte~) animate::$31 [ ]
to:animate::@return
animate::@return: scope:[animate] from animate::@11 animate::@12 animate::@4
[51] return [ ]
@ -103,7 +103,7 @@ render: scope:[render] from main::@1
[52] phi() [ numpoints#1 ]
to:render::@1
render::@1: scope:[render] from render render::@3
[53] (byte*) render::colline#2 ← phi( render/(word) 55296 render::@3/(byte*) render::colline#1 ) [ render::y#2 render::colline#2 numpoints#1 ]
[53] (byte*) render::colline#2 ← phi( render/(const byte*) COLORS#0 render::@3/(byte*) render::colline#1 ) [ render::y#2 render::colline#2 numpoints#1 ]
[53] (byte) render::y#2 ← phi( render/(byte) 0 render::@3/(byte) render::y#1 ) [ render::y#2 render::colline#2 numpoints#1 ]
to:render::@2
render::@2: scope:[render] from render::@1 render::@5
@ -133,8 +133,8 @@ findcol::@1: scope:[findcol] from findcol findcol::@19
[67] (byte) findcol::mincol#11 ← phi( findcol/(byte) 0 findcol::@19/(byte) findcol::mincol#2 ) [ findcol::x#0 findcol::y#0 findcol::i#12 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
[67] (byte) findcol::mindiff#10 ← phi( findcol/(byte) 255 findcol::@19/(byte~) findcol::mindiff#13 ) [ findcol::x#0 findcol::y#0 findcol::i#12 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
[67] (byte) findcol::i#12 ← phi( findcol/(byte) 0 findcol::@19/(byte) findcol::i#1 ) [ findcol::x#0 findcol::y#0 findcol::i#12 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
[68] (byte) findcol::xp#0 ← (word) 4096 *idx (byte) findcol::i#12 [ findcol::x#0 findcol::y#0 findcol::i#12 findcol::mindiff#10 findcol::mincol#11 findcol::xp#0 numpoints#1 ]
[69] (byte) findcol::yp#0 ← (word) 4352 *idx (byte) findcol::i#12 [ findcol::x#0 findcol::y#0 findcol::i#12 findcol::mindiff#10 findcol::mincol#11 findcol::xp#0 findcol::yp#0 numpoints#1 ]
[68] (byte) findcol::xp#0 ← (const byte[256]) XPOS#0 *idx (byte) findcol::i#12 [ findcol::x#0 findcol::y#0 findcol::i#12 findcol::mindiff#10 findcol::mincol#11 findcol::xp#0 numpoints#1 ]
[69] (byte) findcol::yp#0 ← (const byte[256]) YPOS#0 *idx (byte) findcol::i#12 [ findcol::x#0 findcol::y#0 findcol::i#12 findcol::mindiff#10 findcol::mincol#11 findcol::xp#0 findcol::yp#0 numpoints#1 ]
[70] if((byte) findcol::x#0!=(byte) findcol::xp#0) goto findcol::@2 [ findcol::x#0 findcol::y#0 findcol::i#12 findcol::mindiff#10 findcol::mincol#11 findcol::xp#0 findcol::yp#0 numpoints#1 ]
to:findcol::@9
findcol::@9: scope:[findcol] from findcol::@1
@ -163,7 +163,7 @@ findcol::@7: scope:[findcol] from findcol::@14 findcol::@6
[81] if((byte) findcol::diff#6>=(byte) findcol::mindiff#10) goto findcol::@21 [ findcol::x#0 findcol::y#0 findcol::i#12 findcol::mindiff#10 findcol::mincol#11 findcol::diff#6 numpoints#1 ]
to:findcol::@16
findcol::@16: scope:[findcol] from findcol::@7
[82] (byte) findcol::mincol#1 ← (word) 4608 *idx (byte) findcol::i#12 [ findcol::x#0 findcol::y#0 findcol::i#12 findcol::diff#6 findcol::mincol#1 numpoints#1 ]
[82] (byte) findcol::mincol#1 ← (const byte[256]) COLS#0 *idx (byte) findcol::i#12 [ findcol::x#0 findcol::y#0 findcol::i#12 findcol::diff#6 findcol::mincol#1 numpoints#1 ]
to:findcol::@8
findcol::@8: scope:[findcol] from findcol::@16 findcol::@21
[83] (byte) findcol::mindiff#11 ← phi( findcol::@16/(byte) findcol::diff#6 findcol::@21/(byte~) findcol::mindiff#14 ) [ findcol::x#0 findcol::y#0 findcol::i#12 findcol::mincol#2 findcol::mindiff#11 numpoints#1 ]
@ -188,10 +188,10 @@ initscreen: scope:[initscreen] from main::@8
[91] phi() [ ]
to:initscreen::@1
initscreen::@1: scope:[initscreen] from initscreen initscreen::@1
[92] (byte*) initscreen::screen#2 ← phi( initscreen/(word) 1024 initscreen::@1/(byte*) initscreen::screen#1 ) [ initscreen::screen#2 ]
[93] *((byte*) initscreen::screen#2) ← (byte) 230 [ initscreen::screen#2 ]
[92] (byte*) initscreen::screen#2 ← phi( initscreen/(const byte*) SCREEN#0 initscreen::@1/(byte*) initscreen::screen#1 ) [ initscreen::screen#2 ]
[93] *((byte*) initscreen::screen#2) ← (const byte) FILL#0 [ initscreen::screen#2 ]
[94] (byte*) initscreen::screen#1 ← ++ (byte*) initscreen::screen#2 [ initscreen::screen#1 ]
[95] if((byte*) initscreen::screen#1<(word) 2024) goto initscreen::@1 [ initscreen::screen#1 ]
[95] if((byte*) initscreen::screen#1<(const byte*) SCREEN#0+(word) 1000) goto initscreen::@1 [ initscreen::screen#1 ]
to:initscreen::@return
initscreen::@return: scope:[initscreen] from initscreen::@1
[96] return [ ]
@ -201,9 +201,9 @@ addpoint: scope:[addpoint] from main main::@3 main::@4 main::@5 main::@6 main::
[97] (byte) addpoint::y#6 ← phi( main/(byte) 5 main::@3/(byte) 8 main::@4/(byte) 14 main::@5/(byte) 2 main::@6/(byte) 17 main::@7/(byte) 22 ) [ addpoint::x#6 numpoints#19 addpoint::y#6 addpoint::c#6 ]
[97] (byte) numpoints#19 ← phi( main/(byte) 0 main::@3/(byte) numpoints#1 main::@4/(byte) numpoints#1 main::@5/(byte) numpoints#1 main::@6/(byte) numpoints#1 main::@7/(byte) numpoints#1 ) [ addpoint::x#6 numpoints#19 addpoint::y#6 addpoint::c#6 ]
[97] (byte) addpoint::x#6 ← phi( main/(byte) 5 main::@3/(byte) 15 main::@4/(byte) 6 main::@5/(byte) 34 main::@6/(byte) 21 main::@7/(byte) 31 ) [ addpoint::x#6 numpoints#19 addpoint::y#6 addpoint::c#6 ]
[98] *((word) 4096 + (byte) numpoints#19) ← (byte) addpoint::x#6 [ numpoints#19 addpoint::y#6 addpoint::c#6 ]
[99] *((word) 4352 + (byte) numpoints#19) ← (byte) addpoint::y#6 [ numpoints#19 addpoint::c#6 ]
[100] *((word) 4608 + (byte) numpoints#19) ← (byte) addpoint::c#6 [ numpoints#19 ]
[98] *((const byte[256]) XPOS#0 + (byte) numpoints#19) ← (byte) addpoint::x#6 [ numpoints#19 addpoint::y#6 addpoint::c#6 ]
[99] *((const byte[256]) YPOS#0 + (byte) numpoints#19) ← (byte) addpoint::y#6 [ numpoints#19 addpoint::c#6 ]
[100] *((const byte[256]) COLS#0 + (byte) numpoints#19) ← (byte) addpoint::c#6 [ numpoints#19 ]
[101] (byte) numpoints#1 ← ++ (byte) numpoints#19 [ numpoints#1 ]
to:addpoint::@return
addpoint::@return: scope:[addpoint] from addpoint

4302
src/main/java/dk/camelot64/kickc/test/ref/voronoi.log
View File

File diff suppressed because it is too large Load Diff

6
src/main/java/dk/camelot64/kickc/test/ref/voronoi.sym
View File

@ -1,11 +1,17 @@
(label) @begin
(label) @end
(byte*) COLORS
(const byte*) COLORS#0 = (word) 55296
(byte[256]) COLS
(const byte[256]) COLS#0 = (word) 4608
(byte) FILL
(const byte) FILL#0 = (byte) 230
(byte*) SCREEN
(const byte*) SCREEN#0 = (word) 1024
(byte[256]) XPOS
(const byte[256]) XPOS#0 = (word) 4096
(byte[256]) YPOS
(const byte[256]) YPOS#0 = (word) 4352
(void()) addpoint((byte) addpoint::x , (byte) addpoint::y , (byte) addpoint::c)
(label) addpoint::@return
(byte) addpoint::c

46
src/main/java/dk/camelot64/kickc/test/ref/zpparammin.log
View File

@ -666,6 +666,14 @@ sum2::@return: scope:[sum2] from sum2
to:@return
@end: scope:[] from @begin
Not aliassing across scopes: sum::a#0 main::i#2
Not aliassing across scopes: sum::b#0 main::$0
Not aliassing across scopes: sum::c#0 main::$1
Not aliassing across scopes: main::$2 sum::return#0
Not aliassing across scopes: sum2::a#0 main::i#2
Not aliassing across scopes: sum2::b#0 main::$3
Not aliassing across scopes: sum2::c#0 main::$4
Not aliassing across scopes: main::$5 sum2::return#0
Self Phi Eliminated (byte*) SCREEN#1
Self Phi Eliminated (byte*) SCREEN2#1
Succesful SSA optimization Pass2SelfPhiElimination
@ -782,9 +790,9 @@ sum2::@return: scope:[sum2] from sum2
to:@return
@end: scope:[] from @begin
Constant (const byte*) SCREEN#0
Constant (const byte*) SCREEN2#0
Constant (const byte) main::i#0
Constant (const byte*) SCREEN#0 = 1024
Constant (const byte*) SCREEN2#0 = 1024+40
Constant (const byte) main::i#0 = 0
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
@ -838,17 +846,9 @@ sum2::@return: scope:[sum2] from sum2
to:@return
@end: scope:[] from @begin
Not aliassing across scopes: sum::a#0 main::i#2
Not aliassing across scopes: sum::b#0 main::$0
Not aliassing across scopes: sum::c#0 main::$1
Not aliassing across scopes: main::$2 sum::return#0
Not aliassing across scopes: sum2::a#0 main::i#2
Not aliassing across scopes: sum2::b#0 main::$3
Not aliassing across scopes: sum2::c#0 main::$4
Not aliassing across scopes: main::$5 sum2::return#0
Redundant Phi (byte*) SCREEN#1 (const byte*) SCREEN#0
Redundant Phi (byte*) SCREEN2#1 (const byte*) SCREEN2#0
Succesful SSA optimization Pass2RedundantPhiElimination
Constant (const byte*) SCREEN#1 = SCREEN#0
Constant (const byte*) SCREEN2#1 = SCREEN2#0
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[] from
call main param-assignment
@ -866,7 +866,7 @@ main::@1: scope:[main] from main main::@4
to:main::@3
main::@3: scope:[main] from main::@1
(byte~) main::$2 ← (byte) sum::return#0
*((const byte*) SCREEN#0 + (byte) main::i#2) ← (byte~) main::$2
*((const byte*) SCREEN#1 + (byte) main::i#2) ← (byte~) main::$2
(byte~) main::$3 ← (byte) main::i#2 + (byte) 1
(byte~) main::$4 ← (byte) main::i#2 + (byte) 2
(byte) sum2::a#0 ← (byte) main::i#2
@ -876,7 +876,7 @@ main::@3: scope:[main] from main::@1
to:main::@4
main::@4: scope:[main] from main::@3
(byte~) main::$5 ← (byte) sum2::return#0
*((const byte*) SCREEN2#0 + (byte) main::i#2) ← (byte~) main::$5
*((const byte*) SCREEN2#1 + (byte) main::i#2) ← (byte~) main::$5
(byte) main::i#1 ← ++ (byte) main::i#2
if((byte) main::i#1!=(byte) 11) goto main::@1
to:main::@return
@ -899,6 +899,12 @@ sum2::@return: scope:[sum2] from sum2
to:@return
@end: scope:[] 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
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Not aliassing across scopes: sum::a#0 main::i#2
Not aliassing across scopes: sum::b#0 main::$0
Not aliassing across scopes: sum::c#0 main::$1
@ -907,6 +913,14 @@ Not aliassing across scopes: sum2::a#0 main::i#2
Not aliassing across scopes: sum2::b#0 main::$3
Not aliassing across scopes: sum2::c#0 main::$4
Not aliassing across scopes: main::$5 sum2::return#0
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Constant inlined SCREEN#1 = (const byte*) SCREEN#0
Constant inlined SCREEN2#1 = (const byte*) SCREEN2#0
Constant inlined main::i#0 = (byte) 0
Succesful SSA optimization Pass2ConstantInlining
CONTROL FLOW GRAPH