mirror of
https://gitlab.com/camelot/kickc.git
synced 2024-09-08 17:54:40 +00:00
Improved program flow for if-statements without else by inverting the condition and jumping over the stmts. Improved fragment synthesizing.
This commit is contained in:
jespergravgaard
parent
7b30fa4f2c
commit
d5f62dfd11
@ -132,6 +132,7 @@ public class Compiler {
|
||||
optimizations.add(new Pass2CullEmptyBlocks(program));
|
||||
optimizations.add(new Pass2ConstantPropagation(program));
|
||||
optimizations.add(new Pass2ConstantAdditionElimination(program));
|
||||
optimizations.add(new Pass2UnaryNotSimplification(program));
|
||||
optimizations.add(new Pass2AliasElimination(program));
|
||||
optimizations.add(new Pass2RedundantPhiElimination(program));
|
||||
optimizations.add(new Pass2SelfPhiElimination(program));
|
||||
|
||||
@ -1,6 +1,5 @@
|
||||
package dk.camelot64.kickc.asm;
|
||||
|
||||
import dk.camelot64.kickc.CompileLog;
|
||||
import dk.camelot64.kickc.asm.parser.Asm6502Lexer;
|
||||
import dk.camelot64.kickc.asm.parser.Asm6502Parser;
|
||||
import org.antlr.v4.runtime.*;
|
||||
@ -10,6 +9,8 @@ import java.io.InputStream;
|
||||
import java.net.URL;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
/**
|
||||
* Provides fragments from their signature.
|
||||
@ -82,23 +83,34 @@ public class AsmFragmentManager {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
if(signature.contains("_lt_xby_then_")) {
|
||||
int pos = signature.indexOf("_lt_xby_then_");
|
||||
String subSignature = "xby_ge_"+signature.substring(0, pos)+"_then_"+signature.substring(pos+13);
|
||||
return loadOrSynthesizeFragment(subSignature);
|
||||
}
|
||||
if(signature.contains("_lt_yby_then_")) {
|
||||
int pos = signature.indexOf("_lt_yby_then_");
|
||||
String subSignature = "yby_ge_"+signature.substring(0, pos)+"_then_"+signature.substring(pos+13);
|
||||
return loadOrSynthesizeFragment(subSignature);
|
||||
}
|
||||
if(signature.contains("_lt_aby_then_")) {
|
||||
int pos = signature.indexOf("_lt_aby_then_");
|
||||
String subSignature = "aby_ge_"+signature.substring(0, pos)+"_then_"+signature.substring(pos+13);
|
||||
return loadOrSynthesizeFragment(subSignature);
|
||||
|
||||
String sigNew = signature;
|
||||
sigNew = regexpRewriteSignature(sigNew, "(.*)_ge_aby_then_(.*)", "aby_lt_$1_then_$2");
|
||||
sigNew = regexpRewriteSignature(sigNew, "(.*)_ge_xby_then_(.*)", "xby_lt_$1_then_$2");
|
||||
sigNew = regexpRewriteSignature(sigNew, "(.*)_ge_yby_then_(.*)", "yby_lt_$1_then_$2");
|
||||
sigNew = regexpRewriteSignature(sigNew, "(.*)_gt_aby_then_(.*)", "aby_le_$1_then_$2");
|
||||
sigNew = regexpRewriteSignature(sigNew, "(.*)_gt_xby_then_(.*)", "xby_le_$1_then_$2");
|
||||
sigNew = regexpRewriteSignature(sigNew, "(.*)_gt_yby_then_(.*)", "yby_le_$1_then_$2");
|
||||
sigNew = regexpRewriteSignature(sigNew, "(.*)_neq_aby_then_(.*)", "aby_neq_$1_then_$2");
|
||||
sigNew = regexpRewriteSignature(sigNew, "(.*)_neq_xby_then_(.*)", "xby_neq_$1_then_$2");
|
||||
sigNew = regexpRewriteSignature(sigNew, "(.*)_neq_yby_then_(.*)", "yby_neq_$1_then_$2");
|
||||
if(!signature.equals(sigNew)) {
|
||||
return loadFragment(sigNew);
|
||||
}
|
||||
|
||||
return null;
|
||||
|
||||
}
|
||||
|
||||
private static String regexpRewriteSignature(String signature, String match, String replace) {
|
||||
Pattern p = Pattern.compile(match);
|
||||
Matcher m = p.matcher(signature);
|
||||
String output = signature;
|
||||
if (m.find()) {
|
||||
// replace first number with "number" and second number with the first
|
||||
output = m.replaceAll(replace);
|
||||
}
|
||||
return output;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -0,0 +1,3 @@
|
||||
cmp #{coby1}
|
||||
bcc {la1}
|
||||
beq {la1}
|
||||
@ -0,0 +1,2 @@
|
||||
cmp {zpby1}
|
||||
bne {la1}
|
||||
@ -0,0 +1,3 @@
|
||||
lda #{coby1}
|
||||
cmp {zpby1}
|
||||
bcs {la1}
|
||||
@ -0,0 +1,3 @@
|
||||
cpx #{coby1}
|
||||
bcc {la1}
|
||||
beq {la1}
|
||||
@ -0,0 +1,2 @@
|
||||
cpx {zpby1}
|
||||
bne {la1}
|
||||
@ -0,0 +1,3 @@
|
||||
cpy #{coby1}
|
||||
bcc {la1}
|
||||
beq {la1}
|
||||
@ -0,0 +1,2 @@
|
||||
cpy {zpby1}
|
||||
bne {la1}
|
||||
@ -0,0 +1,3 @@
|
||||
lda {zpby1}
|
||||
cmp {zpby2}
|
||||
bcs {la1}
|
||||
@ -0,0 +1,3 @@
|
||||
lda {zpby1}
|
||||
cmp {zpby2}
|
||||
bne {la1}
|
||||
@ -83,18 +83,18 @@ public class Pass1GenerateStatementSequence extends KickCBaseVisitor<Object> {
|
||||
public Void visitStmtIfElse(KickCParser.StmtIfElseContext ctx) {
|
||||
PrePostModifierHandler.addPreModifiers(this, ctx.expr());
|
||||
RValue rValue = (RValue) this.visit(ctx.expr());
|
||||
VariableRef notExprVar = getCurrentSymbols().addVariableIntermediate().getRef();
|
||||
sequence.addStatement(new StatementAssignment(notExprVar, null, new Operator("!"), rValue));
|
||||
PrePostModifierHandler.addPostModifiers(this, ctx.expr());
|
||||
Label ifJumpLabel = getCurrentSymbols().addLabelIntermediate();
|
||||
|
||||
Label elseJumpLabel = getCurrentSymbols().addLabelIntermediate();
|
||||
Statement ifJmpStmt = new StatementConditionalJump(rValue, ifJumpLabel.getRef());
|
||||
Statement ifJmpStmt = new StatementConditionalJump(notExprVar, elseJumpLabel.getRef());
|
||||
sequence.addStatement(ifJmpStmt);
|
||||
Statement elseJmpStmt = new StatementJump(elseJumpLabel.getRef());
|
||||
sequence.addStatement(elseJmpStmt);
|
||||
StatementLabel ifJumpTarget = new StatementLabel(ifJumpLabel.getRef());
|
||||
sequence.addStatement(ifJumpTarget);
|
||||
this.visit(ctx.stmt(0));
|
||||
|
||||
KickCParser.StmtContext elseStmt = ctx.stmt(1);
|
||||
if (elseStmt != null) {
|
||||
// There is an else statement - add the else part and any needed labels/jumps
|
||||
Label endJumpLabel = getCurrentSymbols().addLabelIntermediate();
|
||||
Statement endJmpStmt = new StatementJump(endJumpLabel.getRef());
|
||||
sequence.addStatement(endJmpStmt);
|
||||
@ -104,6 +104,7 @@ public class Pass1GenerateStatementSequence extends KickCBaseVisitor<Object> {
|
||||
StatementLabel endJumpTarget = new StatementLabel(endJumpLabel.getRef());
|
||||
sequence.addStatement(endJumpTarget);
|
||||
} else {
|
||||
// No else statement - just add the label
|
||||
StatementLabel elseJumpTarget = new StatementLabel(elseJumpLabel.getRef());
|
||||
sequence.addStatement(elseJumpTarget);
|
||||
}
|
||||
|
||||
@ -68,8 +68,6 @@ public class Pass2ConditionalJumpSimplification extends Pass2SsaOptimization {
|
||||
};
|
||||
visitor.visitGraph(getGraph());
|
||||
return simpleConditionVars;
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -0,0 +1,105 @@
|
||||
package dk.camelot64.kickc.passes;
|
||||
|
||||
import dk.camelot64.kickc.icl.*;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Compiler Pass simplifying unary not variables if they reference a comparison that can be inverted
|
||||
*/
|
||||
public class Pass2UnaryNotSimplification extends Pass2SsaOptimization {
|
||||
|
||||
public Pass2UnaryNotSimplification(Program program) {
|
||||
super(program);
|
||||
}
|
||||
|
||||
/**
|
||||
* Eliminate unary nots if they are the only usage of a reversable comparison
|
||||
*/
|
||||
@Override
|
||||
public boolean optimize() {
|
||||
final Map<VariableRef, Integer> usages = countVarUsages();
|
||||
final Map<LValue, StatementAssignment> assignments = getAllAssignments();
|
||||
final List<VariableRef> unusedComparisons = optimizeUnaryNots(assignments, usages);
|
||||
removeAssignments(unusedComparisons);
|
||||
deleteVariables(unusedComparisons);
|
||||
return (unusedComparisons.size() > 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Examine all unary nots. If they are the only usage of a reversable unary not replace the unary not with the reversed comparison - and eliminate the riginal variable.
|
||||
*
|
||||
* @param assignments Assignments to examine
|
||||
* @param usages All variable usages
|
||||
* @return Unused comparisons (because they have been replaced with reversed comparisions)
|
||||
*/
|
||||
private List<VariableRef> optimizeUnaryNots(final Map<LValue, StatementAssignment> assignments, final Map<VariableRef, Integer> usages) {
|
||||
|
||||
final List<VariableRef> unused = new ArrayList<>();
|
||||
for (StatementAssignment assignment : assignments.values()) {
|
||||
if (assignment.getrValue1() == null
|
||||
&& assignment.getOperator() != null
|
||||
&& ("!".equals(assignment.getOperator().getOperator()) || "not".equals(assignment.getOperator().getOperator()))
|
||||
&& assignment.getrValue2() instanceof VariableRef
|
||||
) {
|
||||
VariableRef tempVar = (VariableRef) assignment.getrValue2();
|
||||
StatementAssignment tempAssignment = assignments.get(tempVar);
|
||||
if (usages.get(tempVar) == 1 && tempAssignment.getOperator() != null) {
|
||||
switch(tempAssignment.getOperator().getOperator()) {
|
||||
case "<":
|
||||
createInverse(">=", assignment, tempAssignment);
|
||||
unused.add(tempVar);
|
||||
break;
|
||||
case ">":
|
||||
createInverse("<=", assignment, tempAssignment);
|
||||
unused.add(tempVar);
|
||||
break;
|
||||
case "<=":
|
||||
case "=<":
|
||||
createInverse(">", assignment, tempAssignment);
|
||||
unused.add(tempVar);
|
||||
break;
|
||||
case ">=":
|
||||
case "=>":
|
||||
createInverse("<", assignment, tempAssignment);
|
||||
unused.add(tempVar);
|
||||
break;
|
||||
case "==":
|
||||
createInverse("!=", assignment, tempAssignment);
|
||||
unused.add(tempVar);
|
||||
break;
|
||||
case "!=":
|
||||
case "<>":
|
||||
createInverse("==", assignment, tempAssignment);
|
||||
unused.add(tempVar);
|
||||
break;
|
||||
case "!":
|
||||
case "not":
|
||||
createInverse(null, assignment, tempAssignment);
|
||||
unused.add(tempVar);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return unused;
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates an assignment to be the inverse of the temp assignment.
|
||||
*
|
||||
* @param newOperator The new operator to use
|
||||
* @param assignment The assignment to update
|
||||
* @param tempAssignment The temp assignment to take rValues from.
|
||||
*/
|
||||
private void createInverse(String newOperator, StatementAssignment assignment, StatementAssignment tempAssignment) {
|
||||
assignment.setrValue1(tempAssignment.getrValue1());
|
||||
assignment.setOperator(newOperator==null?null:new Operator(newOperator));
|
||||
assignment.setrValue2(tempAssignment.getrValue2());
|
||||
getLog().append("Inversing boolean not "+assignment.toString(getProgram()) +" from "+tempAssignment.toString(getProgram()));
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@ -21,12 +21,7 @@ b1:
|
||||
adc #$18
|
||||
tax
|
||||
cpx #$27
|
||||
bcs b2
|
||||
b3:
|
||||
lda $4
|
||||
cmp #$28
|
||||
bcc b1
|
||||
b2:
|
||||
bcc b2
|
||||
inc $5
|
||||
lda $2
|
||||
clc
|
||||
@ -39,4 +34,7 @@ b2:
|
||||
sec
|
||||
sbc #$27
|
||||
tax
|
||||
jmp b3
|
||||
b2:
|
||||
lda $4
|
||||
cmp #$28
|
||||
bcc b1
|
||||
|
||||
@ -1,25 +1,25 @@
|
||||
@begin: scope:[] from
|
||||
to:@1
|
||||
@1: scope:[] from @3 @begin
|
||||
[0] (byte) y#2 ← phi( @3/(byte) y#4 @begin/(byte) 0 ) [ cursor#3 x#2 e#3 y#2 ]
|
||||
[0] (byte) e#3 ← phi( @3/(byte) e#5 @begin/(byte) 12 ) [ cursor#3 x#2 e#3 y#2 ]
|
||||
[0] (byte) x#2 ← phi( @3/(byte) x#1 @begin/(byte) 0 ) [ cursor#3 x#2 e#3 y#2 ]
|
||||
[0] (byte*) cursor#3 ← phi( @3/(byte*) cursor#5 @begin/(word) 1024 ) [ cursor#3 x#2 e#3 y#2 ]
|
||||
@1: scope:[] from @2 @begin
|
||||
[0] (byte) y#2 ← phi( @2/(byte) y#4 @begin/(byte) 0 ) [ cursor#3 x#2 e#3 y#2 ]
|
||||
[0] (byte) e#3 ← phi( @2/(byte) e#5 @begin/(byte) 12 ) [ cursor#3 x#2 e#3 y#2 ]
|
||||
[0] (byte) x#2 ← phi( @2/(byte) x#1 @begin/(byte) 0 ) [ cursor#3 x#2 e#3 y#2 ]
|
||||
[0] (byte*) cursor#3 ← phi( @2/(byte*) cursor#5 @begin/(word) 1024 ) [ cursor#3 x#2 e#3 y#2 ]
|
||||
[1] *((byte*) cursor#3) ← (byte) 81 [ cursor#3 x#2 e#3 y#2 ]
|
||||
[2] (byte) x#1 ← (byte) x#2 + (byte) 1 [ x#1 cursor#3 e#3 y#2 ]
|
||||
[3] (byte*) cursor#1 ← (byte*) cursor#3 + (byte) 1 [ x#1 e#3 cursor#1 y#2 ]
|
||||
[4] (byte) e#1 ← (byte) e#3 + (byte) 24 [ x#1 e#1 cursor#1 y#2 ]
|
||||
[5] if((byte) 39<(byte) e#1) goto @2 [ x#1 e#1 cursor#1 y#2 ]
|
||||
[3] (byte*) cursor#1 ← (byte*) cursor#3 + (byte) 1 [ x#1 e#3 y#2 cursor#1 ]
|
||||
[4] (byte) e#1 ← (byte) e#3 + (byte) 24 [ x#1 e#1 y#2 cursor#1 ]
|
||||
[5] if((byte) 39>=(byte) e#1) goto @2 [ x#1 e#1 y#2 cursor#1 ]
|
||||
to:@3
|
||||
@3: scope:[] from @1 @2
|
||||
[6] (byte) y#4 ← phi( @1/(byte) y#2 @2/(byte) y#1 ) [ cursor#5 x#1 e#5 y#4 ]
|
||||
[6] (byte) e#5 ← phi( @1/(byte) e#1 @2/(byte) e#2 ) [ cursor#5 x#1 e#5 y#4 ]
|
||||
[6] (byte*) cursor#5 ← phi( @1/(byte*) cursor#1 @2/(byte*) cursor#2 ) [ cursor#5 x#1 e#5 y#4 ]
|
||||
[7] if((byte) x#1<(byte) 40) goto @1 [ cursor#5 x#1 e#5 y#4 ]
|
||||
@3: scope:[] from @1
|
||||
[6] (byte) y#1 ← (byte) y#2 + (byte) 1 [ x#1 e#1 cursor#1 y#1 ]
|
||||
[7] (byte*) cursor#2 ← (byte*) cursor#1 + (byte) 40 [ x#1 e#1 cursor#2 y#1 ]
|
||||
[8] (byte) e#2 ← (byte) e#1 - (byte) 39 [ x#1 cursor#2 e#2 y#1 ]
|
||||
to:@2
|
||||
@2: scope:[] from @1 @3
|
||||
[9] (byte) y#4 ← phi( @1/(byte) y#2 @3/(byte) y#1 ) [ cursor#5 x#1 e#5 y#4 ]
|
||||
[9] (byte) e#5 ← phi( @1/(byte) e#1 @3/(byte) e#2 ) [ cursor#5 x#1 e#5 y#4 ]
|
||||
[9] (byte*) cursor#5 ← phi( @1/(byte*) cursor#1 @3/(byte*) cursor#2 ) [ cursor#5 x#1 e#5 y#4 ]
|
||||
[10] if((byte) x#1<(byte) 40) goto @1 [ cursor#5 x#1 e#5 y#4 ]
|
||||
to:@end
|
||||
@end: scope:[] from @3
|
||||
@2: scope:[] from @1
|
||||
[8] (byte) y#1 ← (byte) y#2 + (byte) 1 [ x#1 e#1 cursor#1 y#1 ]
|
||||
[9] (byte*) cursor#2 ← (byte*) cursor#1 + (byte) 40 [ x#1 e#1 cursor#2 y#1 ]
|
||||
[10] (byte) e#2 ← (byte) e#1 - (byte) 39 [ x#1 cursor#2 e#2 y#1 ]
|
||||
to:@3
|
||||
@end: scope:[] from @2
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -3,13 +3,11 @@ main: {
|
||||
ldx #$0
|
||||
b1:
|
||||
cpx #$32
|
||||
bcc b2
|
||||
b3:
|
||||
bcs b2
|
||||
stx $400
|
||||
b2:
|
||||
inx
|
||||
cpx #$64
|
||||
bcc b1
|
||||
rts
|
||||
b2:
|
||||
stx $400
|
||||
jmp b3
|
||||
}
|
||||
|
||||
@ -4,17 +4,17 @@
|
||||
@end: scope:[] from @begin
|
||||
main: scope:[main] from @begin
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@3
|
||||
[1] (byte) main::i#2 ← phi( main/(byte) 0 main::@3/(byte) main::i#1 ) [ main::i#2 ]
|
||||
[2] if((byte) main::i#2<(byte) 50) goto main::@2 [ main::i#2 ]
|
||||
main::@1: scope:[main] from main main::@2
|
||||
[1] (byte) main::i#2 ← phi( main/(byte) 0 main::@2/(byte) main::i#1 ) [ main::i#2 ]
|
||||
[2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ]
|
||||
to:main::@3
|
||||
main::@3: scope:[main] from main::@1 main::@2
|
||||
[3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ]
|
||||
[4] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ]
|
||||
main::@3: scope:[main] from main::@1
|
||||
[3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ]
|
||||
to:main::@2
|
||||
main::@2: scope:[main] from main::@1 main::@3
|
||||
[4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ]
|
||||
[5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ]
|
||||
to:main::@return
|
||||
main::@return: scope:[main] from main::@3
|
||||
[5] return [ ]
|
||||
main::@return: scope:[main] from main::@2
|
||||
[6] return [ ]
|
||||
to:@return
|
||||
main::@2: scope:[main] from main::@1
|
||||
[6] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ]
|
||||
to:main::@3
|
||||
|
||||
@ -19,14 +19,13 @@ PROGRAM
|
||||
(byte) main::i ← (byte) 0
|
||||
main::@1:
|
||||
(boolean~) main::$0 ← (byte) main::i < (byte) 50
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
goto main::@3
|
||||
main::@2:
|
||||
(boolean~) main::$1 ← ! (boolean~) main::$0
|
||||
if((boolean~) main::$1) goto main::@2
|
||||
*((byte*) SCREEN) ← (byte) main::i
|
||||
main::@3:
|
||||
main::@2:
|
||||
(byte) main::i ← ++ (byte) main::i
|
||||
(boolean~) main::$1 ← (byte) main::i < (byte) 100
|
||||
if((boolean~) main::$1) goto main::@1
|
||||
(boolean~) main::$2 ← (byte) main::i < (byte) 100
|
||||
if((boolean~) main::$2) goto main::@1
|
||||
main::@return:
|
||||
return
|
||||
endproc // main()
|
||||
@ -37,9 +36,9 @@ SYMBOLS
|
||||
(void()) main()
|
||||
(boolean~) main::$0
|
||||
(boolean~) main::$1
|
||||
(boolean~) main::$2
|
||||
(label) main::@1
|
||||
(label) main::@2
|
||||
(label) main::@3
|
||||
(label) main::@return
|
||||
(byte) main::i
|
||||
|
||||
@ -51,25 +50,22 @@ INITIAL CONTROL FLOW GRAPH
|
||||
main: scope:[main] from
|
||||
(byte) main::i ← (byte) 0
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@3
|
||||
main::@1: scope:[main] from main main::@2
|
||||
(boolean~) main::$0 ← (byte) main::i < (byte) 50
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
to:main::@4
|
||||
main::@2: scope:[main] from main::@1 main::@5
|
||||
*((byte*) SCREEN) ← (byte) main::i
|
||||
(boolean~) main::$1 ← ! (boolean~) main::$0
|
||||
if((boolean~) main::$1) goto main::@2
|
||||
to:main::@3
|
||||
main::@4: scope:[main] from main::@1
|
||||
to:main::@3
|
||||
main::@3: scope:[main] from main::@2 main::@4
|
||||
main::@2: scope:[main] from main::@1 main::@3
|
||||
(byte) main::i ← ++ (byte) main::i
|
||||
(boolean~) main::$1 ← (byte) main::i < (byte) 100
|
||||
if((boolean~) main::$1) goto main::@1
|
||||
to:main::@6
|
||||
main::@5: scope:[main] from
|
||||
(boolean~) main::$2 ← (byte) main::i < (byte) 100
|
||||
if((boolean~) main::$2) goto main::@1
|
||||
to:main::@4
|
||||
main::@3: scope:[main] from main::@1
|
||||
*((byte*) SCREEN) ← (byte) main::i
|
||||
to:main::@2
|
||||
main::@6: scope:[main] from main::@3
|
||||
main::@4: scope:[main] from main::@2
|
||||
to:main::@return
|
||||
main::@return: scope:[main] from main::@6
|
||||
main::@return: scope:[main] from main::@4
|
||||
return
|
||||
to:@return
|
||||
@1: scope:[] from @begin
|
||||
@ -77,8 +73,6 @@ main::@return: scope:[main] from main::@6
|
||||
@end: scope:[] from @1
|
||||
|
||||
Removing empty block main::@4
|
||||
Removing empty block main::@5
|
||||
Removing empty block main::@6
|
||||
Removing empty block @1
|
||||
CONTROL FLOW GRAPH
|
||||
@begin: scope:[] from
|
||||
@ -88,19 +82,20 @@ CONTROL FLOW GRAPH
|
||||
main: scope:[main] from
|
||||
(byte) main::i ← (byte) 0
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@3
|
||||
main::@1: scope:[main] from main main::@2
|
||||
(boolean~) main::$0 ← (byte) main::i < (byte) 50
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
(boolean~) main::$1 ← ! (boolean~) main::$0
|
||||
if((boolean~) main::$1) goto main::@2
|
||||
to:main::@3
|
||||
main::@2: scope:[main] from main::@1
|
||||
*((byte*) SCREEN) ← (byte) main::i
|
||||
to:main::@3
|
||||
main::@3: scope:[main] from main::@1 main::@2
|
||||
main::@2: scope:[main] from main::@1 main::@3
|
||||
(byte) main::i ← ++ (byte) main::i
|
||||
(boolean~) main::$1 ← (byte) main::i < (byte) 100
|
||||
if((boolean~) main::$1) goto main::@1
|
||||
(boolean~) main::$2 ← (byte) main::i < (byte) 100
|
||||
if((boolean~) main::$2) goto main::@1
|
||||
to:main::@return
|
||||
main::@return: scope:[main] from main::@3
|
||||
main::@3: scope:[main] from main::@1
|
||||
*((byte*) SCREEN) ← (byte) main::i
|
||||
to:main::@2
|
||||
main::@return: scope:[main] from main::@2
|
||||
return
|
||||
to:@return
|
||||
@end: scope:[] from @begin
|
||||
@ -117,19 +112,20 @@ CONTROL FLOW GRAPH WITH ASSIGNMENT CALL
|
||||
main: scope:[main] from @begin
|
||||
(byte) main::i ← (byte) 0
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@3
|
||||
main::@1: scope:[main] from main main::@2
|
||||
(boolean~) main::$0 ← (byte) main::i < (byte) 50
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
(boolean~) main::$1 ← ! (boolean~) main::$0
|
||||
if((boolean~) main::$1) goto main::@2
|
||||
to:main::@3
|
||||
main::@2: scope:[main] from main::@1
|
||||
*((byte*) SCREEN) ← (byte) main::i
|
||||
to:main::@3
|
||||
main::@3: scope:[main] from main::@1 main::@2
|
||||
main::@2: scope:[main] from main::@1 main::@3
|
||||
(byte) main::i ← ++ (byte) main::i
|
||||
(boolean~) main::$1 ← (byte) main::i < (byte) 100
|
||||
if((boolean~) main::$1) goto main::@1
|
||||
(boolean~) main::$2 ← (byte) main::i < (byte) 100
|
||||
if((boolean~) main::$2) goto main::@1
|
||||
to:main::@return
|
||||
main::@return: scope:[main] from main::@3
|
||||
main::@3: scope:[main] from main::@1
|
||||
*((byte*) SCREEN) ← (byte) main::i
|
||||
to:main::@2
|
||||
main::@return: scope:[main] from main::@2
|
||||
return
|
||||
to:@return
|
||||
@end: scope:[] from @2
|
||||
@ -148,25 +144,26 @@ main: scope:[main] from @begin
|
||||
(byte*) SCREEN#3 ← phi( @begin/(byte*) SCREEN#0 )
|
||||
(byte) main::i#0 ← (byte) 0
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@3
|
||||
(byte*) SCREEN#2 ← phi( main/(byte*) SCREEN#3 main::@3/(byte*) SCREEN#4 )
|
||||
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@3/(byte) main::i#1 )
|
||||
main::@1: scope:[main] from main main::@2
|
||||
(byte*) SCREEN#2 ← phi( main/(byte*) SCREEN#3 main::@2/(byte*) SCREEN#4 )
|
||||
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@2/(byte) main::i#1 )
|
||||
(boolean~) main::$0 ← (byte) main::i#2 < (byte) 50
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
(boolean~) main::$1 ← ! (boolean~) main::$0
|
||||
if((boolean~) main::$1) goto main::@2
|
||||
to:main::@3
|
||||
main::@2: scope:[main] from main::@1
|
||||
(byte*) SCREEN#1 ← phi( main::@1/(byte*) SCREEN#2 )
|
||||
(byte) main::i#3 ← phi( main::@1/(byte) main::i#2 )
|
||||
*((byte*) SCREEN#1) ← (byte) main::i#3
|
||||
to:main::@3
|
||||
main::@3: scope:[main] from main::@1 main::@2
|
||||
(byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#2 main::@2/(byte*) SCREEN#1 )
|
||||
(byte) main::i#4 ← phi( main::@1/(byte) main::i#2 main::@2/(byte) main::i#3 )
|
||||
(byte) main::i#1 ← ++ (byte) main::i#4
|
||||
(boolean~) main::$1 ← (byte) main::i#1 < (byte) 100
|
||||
if((boolean~) main::$1) goto main::@1
|
||||
main::@2: scope:[main] from main::@1 main::@3
|
||||
(byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#2 main::@3/(byte*) SCREEN#1 )
|
||||
(byte) main::i#3 ← phi( main::@1/(byte) main::i#2 main::@3/(byte) main::i#4 )
|
||||
(byte) main::i#1 ← ++ (byte) main::i#3
|
||||
(boolean~) main::$2 ← (byte) main::i#1 < (byte) 100
|
||||
if((boolean~) main::$2) goto main::@1
|
||||
to:main::@return
|
||||
main::@return: scope:[main] from main::@3
|
||||
main::@3: scope:[main] from main::@1
|
||||
(byte*) SCREEN#1 ← phi( main::@1/(byte*) SCREEN#2 )
|
||||
(byte) main::i#4 ← phi( main::@1/(byte) main::i#2 )
|
||||
*((byte*) SCREEN#1) ← (byte) main::i#4
|
||||
to:main::@2
|
||||
main::@return: scope:[main] from main::@2
|
||||
return
|
||||
to:@return
|
||||
@end: scope:[] from @2
|
||||
@ -182,25 +179,26 @@ main: scope:[main] from @begin
|
||||
(byte*) SCREEN#3 ← phi( @begin/(byte*) SCREEN#0 )
|
||||
(byte) main::i#0 ← (byte) 0
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@3
|
||||
(byte*) SCREEN#2 ← phi( main/(byte*) SCREEN#3 main::@3/(byte*) SCREEN#4 )
|
||||
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@3/(byte) main::i#1 )
|
||||
main::@1: scope:[main] from main main::@2
|
||||
(byte*) SCREEN#2 ← phi( main/(byte*) SCREEN#3 main::@2/(byte*) SCREEN#4 )
|
||||
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@2/(byte) main::i#1 )
|
||||
(boolean~) main::$0 ← (byte) main::i#2 < (byte) 50
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
(boolean~) main::$1 ← ! (boolean~) main::$0
|
||||
if((boolean~) main::$1) goto main::@2
|
||||
to:main::@3
|
||||
main::@2: scope:[main] from main::@1
|
||||
(byte*) SCREEN#1 ← phi( main::@1/(byte*) SCREEN#2 )
|
||||
(byte) main::i#3 ← phi( main::@1/(byte) main::i#2 )
|
||||
*((byte*) SCREEN#1) ← (byte) main::i#3
|
||||
to:main::@3
|
||||
main::@3: scope:[main] from main::@1 main::@2
|
||||
(byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#2 main::@2/(byte*) SCREEN#1 )
|
||||
(byte) main::i#4 ← phi( main::@1/(byte) main::i#2 main::@2/(byte) main::i#3 )
|
||||
(byte) main::i#1 ← ++ (byte) main::i#4
|
||||
(boolean~) main::$1 ← (byte) main::i#1 < (byte) 100
|
||||
if((boolean~) main::$1) goto main::@1
|
||||
main::@2: scope:[main] from main::@1 main::@3
|
||||
(byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#2 main::@3/(byte*) SCREEN#1 )
|
||||
(byte) main::i#3 ← phi( main::@1/(byte) main::i#2 main::@3/(byte) main::i#4 )
|
||||
(byte) main::i#1 ← ++ (byte) main::i#3
|
||||
(boolean~) main::$2 ← (byte) main::i#1 < (byte) 100
|
||||
if((boolean~) main::$2) goto main::@1
|
||||
to:main::@return
|
||||
main::@return: scope:[main] from main::@3
|
||||
main::@3: scope:[main] from main::@1
|
||||
(byte*) SCREEN#1 ← phi( main::@1/(byte*) SCREEN#2 )
|
||||
(byte) main::i#4 ← phi( main::@1/(byte) main::i#2 )
|
||||
*((byte*) SCREEN#1) ← (byte) main::i#4
|
||||
to:main::@2
|
||||
main::@return: scope:[main] from main::@2
|
||||
return
|
||||
to:@return
|
||||
@end: scope:[] from @2
|
||||
@ -216,25 +214,26 @@ main: scope:[main] from @begin
|
||||
(byte*) SCREEN#3 ← phi( @begin/(byte*) SCREEN#0 )
|
||||
(byte) main::i#0 ← (byte) 0
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@3
|
||||
(byte*) SCREEN#2 ← phi( main/(byte*) SCREEN#3 main::@3/(byte*) SCREEN#4 )
|
||||
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@3/(byte) main::i#1 )
|
||||
main::@1: scope:[main] from main main::@2
|
||||
(byte*) SCREEN#2 ← phi( main/(byte*) SCREEN#3 main::@2/(byte*) SCREEN#4 )
|
||||
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@2/(byte) main::i#1 )
|
||||
(boolean~) main::$0 ← (byte) main::i#2 < (byte) 50
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
(boolean~) main::$1 ← ! (boolean~) main::$0
|
||||
if((boolean~) main::$1) goto main::@2
|
||||
to:main::@3
|
||||
main::@2: scope:[main] from main::@1
|
||||
(byte*) SCREEN#1 ← phi( main::@1/(byte*) SCREEN#2 )
|
||||
(byte) main::i#3 ← phi( main::@1/(byte) main::i#2 )
|
||||
*((byte*) SCREEN#1) ← (byte) main::i#3
|
||||
to:main::@3
|
||||
main::@3: scope:[main] from main::@1 main::@2
|
||||
(byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#2 main::@2/(byte*) SCREEN#1 )
|
||||
(byte) main::i#4 ← phi( main::@1/(byte) main::i#2 main::@2/(byte) main::i#3 )
|
||||
(byte) main::i#1 ← ++ (byte) main::i#4
|
||||
(boolean~) main::$1 ← (byte) main::i#1 < (byte) 100
|
||||
if((boolean~) main::$1) goto main::@1
|
||||
main::@2: scope:[main] from main::@1 main::@3
|
||||
(byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#2 main::@3/(byte*) SCREEN#1 )
|
||||
(byte) main::i#3 ← phi( main::@1/(byte) main::i#2 main::@3/(byte) main::i#4 )
|
||||
(byte) main::i#1 ← ++ (byte) main::i#3
|
||||
(boolean~) main::$2 ← (byte) main::i#1 < (byte) 100
|
||||
if((boolean~) main::$2) goto main::@1
|
||||
to:main::@return
|
||||
main::@return: scope:[main] from main::@3
|
||||
main::@3: scope:[main] from main::@1
|
||||
(byte*) SCREEN#1 ← phi( main::@1/(byte*) SCREEN#2 )
|
||||
(byte) main::i#4 ← phi( main::@1/(byte) main::i#2 )
|
||||
*((byte*) SCREEN#1) ← (byte) main::i#4
|
||||
to:main::@2
|
||||
main::@return: scope:[main] from main::@2
|
||||
return
|
||||
to:@return
|
||||
@end: scope:[] from @begin
|
||||
@ -249,30 +248,63 @@ CONTROL FLOW GRAPH
|
||||
main: scope:[main] from @begin
|
||||
(byte*) SCREEN#3 ← phi( @begin/(word) 1024 )
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@3
|
||||
(byte*) SCREEN#2 ← phi( main/(byte*) SCREEN#3 main::@3/(byte*) SCREEN#4 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 0 main::@3/(byte) main::i#1 )
|
||||
main::@1: scope:[main] from main main::@2
|
||||
(byte*) SCREEN#2 ← phi( main/(byte*) SCREEN#3 main::@2/(byte*) SCREEN#4 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 0 main::@2/(byte) main::i#1 )
|
||||
(boolean~) main::$0 ← (byte) main::i#2 < (byte) 50
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
(boolean~) main::$1 ← ! (boolean~) main::$0
|
||||
if((boolean~) main::$1) goto main::@2
|
||||
to:main::@3
|
||||
main::@2: scope:[main] from main::@1
|
||||
(byte*) SCREEN#1 ← phi( main::@1/(byte*) SCREEN#2 )
|
||||
(byte) main::i#3 ← phi( main::@1/(byte) main::i#2 )
|
||||
*((byte*) SCREEN#1) ← (byte) main::i#3
|
||||
to:main::@3
|
||||
main::@3: scope:[main] from main::@1 main::@2
|
||||
(byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#2 main::@2/(byte*) SCREEN#1 )
|
||||
(byte) main::i#4 ← phi( main::@1/(byte) main::i#2 main::@2/(byte) main::i#3 )
|
||||
(byte) main::i#1 ← ++ (byte) main::i#4
|
||||
(boolean~) main::$1 ← (byte) main::i#1 < (byte) 100
|
||||
if((boolean~) main::$1) goto main::@1
|
||||
main::@2: scope:[main] from main::@1 main::@3
|
||||
(byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#2 main::@3/(byte*) SCREEN#1 )
|
||||
(byte) main::i#3 ← phi( main::@1/(byte) main::i#2 main::@3/(byte) main::i#4 )
|
||||
(byte) main::i#1 ← ++ (byte) main::i#3
|
||||
(boolean~) main::$2 ← (byte) main::i#1 < (byte) 100
|
||||
if((boolean~) main::$2) goto main::@1
|
||||
to:main::@return
|
||||
main::@return: scope:[main] from main::@3
|
||||
main::@3: scope:[main] from main::@1
|
||||
(byte*) SCREEN#1 ← phi( main::@1/(byte*) SCREEN#2 )
|
||||
(byte) main::i#4 ← phi( main::@1/(byte) main::i#2 )
|
||||
*((byte*) SCREEN#1) ← (byte) main::i#4
|
||||
to:main::@2
|
||||
main::@return: scope:[main] from main::@2
|
||||
return
|
||||
to:@return
|
||||
@end: scope:[] from @begin
|
||||
|
||||
Alias (byte) main::i#2 = (byte) main::i#3
|
||||
Inversing boolean not (boolean~) main::$1 ← (byte) main::i#2 >= (byte) 50 from (boolean~) main::$0 ← (byte) main::i#2 < (byte) 50
|
||||
Succesful SSA optimization Pass2UnaryNotSimplification
|
||||
CONTROL FLOW GRAPH
|
||||
@begin: scope:[] from
|
||||
call main param-assignment
|
||||
to:@end
|
||||
main: scope:[main] from @begin
|
||||
(byte*) SCREEN#3 ← phi( @begin/(word) 1024 )
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@2
|
||||
(byte*) SCREEN#2 ← phi( main/(byte*) SCREEN#3 main::@2/(byte*) SCREEN#4 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 0 main::@2/(byte) main::i#1 )
|
||||
(boolean~) main::$1 ← (byte) main::i#2 >= (byte) 50
|
||||
if((boolean~) main::$1) goto main::@2
|
||||
to:main::@3
|
||||
main::@2: scope:[main] from main::@1 main::@3
|
||||
(byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#2 main::@3/(byte*) SCREEN#1 )
|
||||
(byte) main::i#3 ← phi( main::@1/(byte) main::i#2 main::@3/(byte) main::i#4 )
|
||||
(byte) main::i#1 ← ++ (byte) main::i#3
|
||||
(boolean~) main::$2 ← (byte) main::i#1 < (byte) 100
|
||||
if((boolean~) main::$2) goto main::@1
|
||||
to:main::@return
|
||||
main::@3: scope:[main] from main::@1
|
||||
(byte*) SCREEN#1 ← phi( main::@1/(byte*) SCREEN#2 )
|
||||
(byte) main::i#4 ← phi( main::@1/(byte) main::i#2 )
|
||||
*((byte*) SCREEN#1) ← (byte) main::i#4
|
||||
to:main::@2
|
||||
main::@return: scope:[main] from main::@2
|
||||
return
|
||||
to:@return
|
||||
@end: scope:[] from @begin
|
||||
|
||||
Alias (byte) main::i#2 = (byte) main::i#4
|
||||
Alias (byte*) SCREEN#1 = (byte*) SCREEN#2
|
||||
Succesful SSA optimization Pass2AliasElimination
|
||||
CONTROL FLOW GRAPH
|
||||
@ -282,29 +314,29 @@ CONTROL FLOW GRAPH
|
||||
main: scope:[main] from @begin
|
||||
(byte*) SCREEN#3 ← phi( @begin/(word) 1024 )
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@3
|
||||
(byte*) SCREEN#1 ← phi( main/(byte*) SCREEN#3 main::@3/(byte*) SCREEN#4 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 0 main::@3/(byte) main::i#1 )
|
||||
(boolean~) main::$0 ← (byte) main::i#2 < (byte) 50
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
main::@1: scope:[main] from main main::@2
|
||||
(byte*) SCREEN#1 ← phi( main/(byte*) SCREEN#3 main::@2/(byte*) SCREEN#4 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 0 main::@2/(byte) main::i#1 )
|
||||
(boolean~) main::$1 ← (byte) main::i#2 >= (byte) 50
|
||||
if((boolean~) main::$1) goto main::@2
|
||||
to:main::@3
|
||||
main::@2: scope:[main] from main::@1
|
||||
*((byte*) SCREEN#1) ← (byte) main::i#2
|
||||
to:main::@3
|
||||
main::@3: scope:[main] from main::@1 main::@2
|
||||
(byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#1 main::@2/(byte*) SCREEN#1 )
|
||||
(byte) main::i#4 ← phi( main::@1/(byte) main::i#2 main::@2/(byte) main::i#2 )
|
||||
(byte) main::i#1 ← ++ (byte) main::i#4
|
||||
(boolean~) main::$1 ← (byte) main::i#1 < (byte) 100
|
||||
if((boolean~) main::$1) goto main::@1
|
||||
main::@2: scope:[main] from main::@1 main::@3
|
||||
(byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#1 main::@3/(byte*) SCREEN#1 )
|
||||
(byte) main::i#3 ← phi( main::@1/(byte) main::i#2 main::@3/(byte) main::i#2 )
|
||||
(byte) main::i#1 ← ++ (byte) main::i#3
|
||||
(boolean~) main::$2 ← (byte) main::i#1 < (byte) 100
|
||||
if((boolean~) main::$2) goto main::@1
|
||||
to:main::@return
|
||||
main::@return: scope:[main] from main::@3
|
||||
main::@3: scope:[main] from main::@1
|
||||
*((byte*) SCREEN#1) ← (byte) main::i#2
|
||||
to:main::@2
|
||||
main::@return: scope:[main] from main::@2
|
||||
return
|
||||
to:@return
|
||||
@end: scope:[] from @begin
|
||||
|
||||
Redundant Phi (byte*) SCREEN#3 (word) 1024
|
||||
Redundant Phi (byte) main::i#4 (byte) main::i#2
|
||||
Redundant Phi (byte) main::i#3 (byte) main::i#2
|
||||
Redundant Phi (byte*) SCREEN#4 (byte*) SCREEN#1
|
||||
Succesful SSA optimization Pass2RedundantPhiElimination
|
||||
CONTROL FLOW GRAPH
|
||||
@ -313,21 +345,21 @@ CONTROL FLOW GRAPH
|
||||
to:@end
|
||||
main: scope:[main] from @begin
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@3
|
||||
(byte*) SCREEN#1 ← phi( main/(word) 1024 main::@3/(byte*) SCREEN#1 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 0 main::@3/(byte) main::i#1 )
|
||||
(boolean~) main::$0 ← (byte) main::i#2 < (byte) 50
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
main::@1: scope:[main] from main main::@2
|
||||
(byte*) SCREEN#1 ← phi( main/(word) 1024 main::@2/(byte*) SCREEN#1 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 0 main::@2/(byte) main::i#1 )
|
||||
(boolean~) main::$1 ← (byte) main::i#2 >= (byte) 50
|
||||
if((boolean~) main::$1) goto main::@2
|
||||
to:main::@3
|
||||
main::@2: scope:[main] from main::@1
|
||||
*((byte*) SCREEN#1) ← (byte) main::i#2
|
||||
to:main::@3
|
||||
main::@3: scope:[main] from main::@1 main::@2
|
||||
main::@2: scope:[main] from main::@1 main::@3
|
||||
(byte) main::i#1 ← ++ (byte) main::i#2
|
||||
(boolean~) main::$1 ← (byte) main::i#1 < (byte) 100
|
||||
if((boolean~) main::$1) goto main::@1
|
||||
(boolean~) main::$2 ← (byte) main::i#1 < (byte) 100
|
||||
if((boolean~) main::$2) goto main::@1
|
||||
to:main::@return
|
||||
main::@return: scope:[main] from main::@3
|
||||
main::@3: scope:[main] from main::@1
|
||||
*((byte*) SCREEN#1) ← (byte) main::i#2
|
||||
to:main::@2
|
||||
main::@return: scope:[main] from main::@2
|
||||
return
|
||||
to:@return
|
||||
@end: scope:[] from @begin
|
||||
@ -340,27 +372,27 @@ CONTROL FLOW GRAPH
|
||||
to:@end
|
||||
main: scope:[main] from @begin
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@3
|
||||
main::@1: scope:[main] from main main::@2
|
||||
(byte*) SCREEN#1 ← phi( main/(word) 1024 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 0 main::@3/(byte) main::i#1 )
|
||||
(boolean~) main::$0 ← (byte) main::i#2 < (byte) 50
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
(byte) main::i#2 ← phi( main/(byte) 0 main::@2/(byte) main::i#1 )
|
||||
(boolean~) main::$1 ← (byte) main::i#2 >= (byte) 50
|
||||
if((boolean~) main::$1) goto main::@2
|
||||
to:main::@3
|
||||
main::@2: scope:[main] from main::@1
|
||||
*((byte*) SCREEN#1) ← (byte) main::i#2
|
||||
to:main::@3
|
||||
main::@3: scope:[main] from main::@1 main::@2
|
||||
main::@2: scope:[main] from main::@1 main::@3
|
||||
(byte) main::i#1 ← ++ (byte) main::i#2
|
||||
(boolean~) main::$1 ← (byte) main::i#1 < (byte) 100
|
||||
if((boolean~) main::$1) goto main::@1
|
||||
(boolean~) main::$2 ← (byte) main::i#1 < (byte) 100
|
||||
if((boolean~) main::$2) goto main::@1
|
||||
to:main::@return
|
||||
main::@return: scope:[main] from main::@3
|
||||
main::@3: scope:[main] from main::@1
|
||||
*((byte*) SCREEN#1) ← (byte) main::i#2
|
||||
to:main::@2
|
||||
main::@return: scope:[main] from main::@2
|
||||
return
|
||||
to:@return
|
||||
@end: scope:[] from @begin
|
||||
|
||||
Simple Condition (boolean~) main::$0 if((byte) main::i#2<(byte) 50) goto main::@2
|
||||
Simple Condition (boolean~) main::$1 if((byte) main::i#1<(byte) 100) goto main::@1
|
||||
Simple Condition (boolean~) main::$1 if((byte) main::i#2>=(byte) 50) goto main::@2
|
||||
Simple Condition (boolean~) main::$2 if((byte) main::i#1<(byte) 100) goto main::@1
|
||||
Succesful SSA optimization Pass2ConditionalJumpSimplification
|
||||
CONTROL FLOW GRAPH
|
||||
@begin: scope:[] from
|
||||
@ -368,19 +400,19 @@ CONTROL FLOW GRAPH
|
||||
to:@end
|
||||
main: scope:[main] from @begin
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@3
|
||||
main::@1: scope:[main] from main main::@2
|
||||
(byte*) SCREEN#1 ← phi( main/(word) 1024 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 0 main::@3/(byte) main::i#1 )
|
||||
if((byte) main::i#2<(byte) 50) goto main::@2
|
||||
(byte) main::i#2 ← phi( main/(byte) 0 main::@2/(byte) main::i#1 )
|
||||
if((byte) main::i#2>=(byte) 50) goto main::@2
|
||||
to:main::@3
|
||||
main::@2: scope:[main] from main::@1
|
||||
*((byte*) SCREEN#1) ← (byte) main::i#2
|
||||
to:main::@3
|
||||
main::@3: scope:[main] from main::@1 main::@2
|
||||
main::@2: scope:[main] from main::@1 main::@3
|
||||
(byte) main::i#1 ← ++ (byte) main::i#2
|
||||
if((byte) main::i#1<(byte) 100) goto main::@1
|
||||
to:main::@return
|
||||
main::@return: scope:[main] from main::@3
|
||||
main::@3: scope:[main] from main::@1
|
||||
*((byte*) SCREEN#1) ← (byte) main::i#2
|
||||
to:main::@2
|
||||
main::@return: scope:[main] from main::@2
|
||||
return
|
||||
to:@return
|
||||
@end: scope:[] from @begin
|
||||
@ -393,25 +425,25 @@ CONTROL FLOW GRAPH
|
||||
to:@end
|
||||
main: scope:[main] from @begin
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@3
|
||||
(byte) main::i#2 ← phi( main/(byte) 0 main::@3/(byte) main::i#1 )
|
||||
if((byte) main::i#2<(byte) 50) goto main::@2
|
||||
main::@1: scope:[main] from main main::@2
|
||||
(byte) main::i#2 ← phi( main/(byte) 0 main::@2/(byte) main::i#1 )
|
||||
if((byte) main::i#2>=(byte) 50) goto main::@2
|
||||
to:main::@3
|
||||
main::@2: scope:[main] from main::@1
|
||||
*((word) 1024) ← (byte) main::i#2
|
||||
to:main::@3
|
||||
main::@3: scope:[main] from main::@1 main::@2
|
||||
main::@2: scope:[main] from main::@1 main::@3
|
||||
(byte) main::i#1 ← ++ (byte) main::i#2
|
||||
if((byte) main::i#1<(byte) 100) goto main::@1
|
||||
to:main::@return
|
||||
main::@return: scope:[main] from main::@3
|
||||
main::@3: scope:[main] from main::@1
|
||||
*((word) 1024) ← (byte) main::i#2
|
||||
to:main::@2
|
||||
main::@return: scope:[main] from main::@2
|
||||
return
|
||||
to:@return
|
||||
@end: scope:[] from @begin
|
||||
|
||||
Block Sequence Planned @begin @end main main::@1 main::@3 main::@return main::@2
|
||||
Added new block during phi lifting main::@7(between main::@3 and main::@1)
|
||||
Block Sequence Planned @begin @end main main::@1 main::@3 main::@return main::@7 main::@2
|
||||
Block Sequence Planned @begin @end main main::@1 main::@3 main::@2 main::@return
|
||||
Added new block during phi lifting main::@5(between main::@2 and main::@1)
|
||||
Block Sequence Planned @begin @end main main::@1 main::@3 main::@2 main::@return main::@5
|
||||
CONTROL FLOW GRAPH - PHI LIFTED
|
||||
@begin: scope:[] from
|
||||
call main param-assignment
|
||||
@ -419,23 +451,23 @@ CONTROL FLOW GRAPH - PHI LIFTED
|
||||
@end: scope:[] from @begin
|
||||
main: scope:[main] from @begin
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@7
|
||||
(byte) main::i#2 ← phi( main/(byte) 0 main::@7/(byte~) main::i#5 )
|
||||
if((byte) main::i#2<(byte) 50) goto main::@2
|
||||
main::@1: scope:[main] from main main::@5
|
||||
(byte) main::i#2 ← phi( main/(byte) 0 main::@5/(byte~) main::i#5 )
|
||||
if((byte) main::i#2>=(byte) 50) goto main::@2
|
||||
to:main::@3
|
||||
main::@3: scope:[main] from main::@1 main::@2
|
||||
main::@3: scope:[main] from main::@1
|
||||
*((word) 1024) ← (byte) main::i#2
|
||||
to:main::@2
|
||||
main::@2: scope:[main] from main::@1 main::@3
|
||||
(byte) main::i#1 ← ++ (byte) main::i#2
|
||||
if((byte) main::i#1<(byte) 100) goto main::@7
|
||||
if((byte) main::i#1<(byte) 100) goto main::@5
|
||||
to:main::@return
|
||||
main::@return: scope:[main] from main::@3
|
||||
main::@return: scope:[main] from main::@2
|
||||
return
|
||||
to:@return
|
||||
main::@7: scope:[main] from main::@3
|
||||
main::@5: scope:[main] from main::@2
|
||||
(byte~) main::i#5 ← (byte) main::i#1
|
||||
to:main::@1
|
||||
main::@2: scope:[main] from main::@1
|
||||
*((word) 1024) ← (byte) main::i#2
|
||||
to:main::@3
|
||||
|
||||
Propagating live ranges...
|
||||
CONTROL FLOW GRAPH - LIVE RANGES
|
||||
@ -445,29 +477,29 @@ CONTROL FLOW GRAPH - LIVE RANGES
|
||||
@end: scope:[] from @begin
|
||||
main: scope:[main] from @begin
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@7
|
||||
[1] (byte) main::i#2 ← phi( main/(byte) 0 main::@7/(byte~) main::i#5 ) [ main::i#2 ]
|
||||
[2] if((byte) main::i#2<(byte) 50) goto main::@2 [ main::i#2 ]
|
||||
main::@1: scope:[main] from main main::@5
|
||||
[1] (byte) main::i#2 ← phi( main/(byte) 0 main::@5/(byte~) main::i#5 ) [ main::i#2 ]
|
||||
[2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ]
|
||||
to:main::@3
|
||||
main::@3: scope:[main] from main::@1 main::@2
|
||||
[3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ]
|
||||
[4] if((byte) main::i#1<(byte) 100) goto main::@7 [ main::i#1 ]
|
||||
main::@3: scope:[main] from main::@1
|
||||
[3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ]
|
||||
to:main::@2
|
||||
main::@2: scope:[main] from main::@1 main::@3
|
||||
[4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ]
|
||||
[5] if((byte) main::i#1<(byte) 100) goto main::@5 [ main::i#1 ]
|
||||
to:main::@return
|
||||
main::@return: scope:[main] from main::@3
|
||||
[5] return [ ]
|
||||
main::@return: scope:[main] from main::@2
|
||||
[6] return [ ]
|
||||
to:@return
|
||||
main::@7: scope:[main] from main::@3
|
||||
[6] (byte~) main::i#5 ← (byte) main::i#1 [ main::i#5 ]
|
||||
main::@5: scope:[main] from main::@2
|
||||
[7] (byte~) main::i#5 ← (byte) main::i#1 [ main::i#5 ]
|
||||
to:main::@1
|
||||
main::@2: scope:[main] from main::@1
|
||||
[7] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ]
|
||||
to:main::@3
|
||||
|
||||
Created 1 initial phi equivalence classes
|
||||
Coalesced [6] main::i#5 ← main::i#1
|
||||
Coalesced [7] main::i#5 ← main::i#1
|
||||
Coalesced down to 1 phi equivalence classes
|
||||
Culled Empty Block (label) main::@7
|
||||
Block Sequence Planned @begin @end main main::@1 main::@3 main::@return main::@2
|
||||
Culled Empty Block (label) main::@5
|
||||
Block Sequence Planned @begin @end main main::@1 main::@3 main::@2 main::@return
|
||||
Propagating live ranges...
|
||||
CONTROL FLOW GRAPH - PHI MEM COALESCED
|
||||
@begin: scope:[] from
|
||||
@ -476,20 +508,20 @@ CONTROL FLOW GRAPH - PHI MEM COALESCED
|
||||
@end: scope:[] from @begin
|
||||
main: scope:[main] from @begin
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@3
|
||||
[1] (byte) main::i#2 ← phi( main/(byte) 0 main::@3/(byte) main::i#1 ) [ main::i#2 ]
|
||||
[2] if((byte) main::i#2<(byte) 50) goto main::@2 [ main::i#2 ]
|
||||
main::@1: scope:[main] from main main::@2
|
||||
[1] (byte) main::i#2 ← phi( main/(byte) 0 main::@2/(byte) main::i#1 ) [ main::i#2 ]
|
||||
[2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ]
|
||||
to:main::@3
|
||||
main::@3: scope:[main] from main::@1 main::@2
|
||||
[3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ]
|
||||
[4] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ]
|
||||
main::@3: scope:[main] from main::@1
|
||||
[3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ]
|
||||
to:main::@2
|
||||
main::@2: scope:[main] from main::@1 main::@3
|
||||
[4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ]
|
||||
[5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ]
|
||||
to:main::@return
|
||||
main::@return: scope:[main] from main::@3
|
||||
[5] return [ ]
|
||||
main::@return: scope:[main] from main::@2
|
||||
[6] return [ ]
|
||||
to:@return
|
||||
main::@2: scope:[main] from main::@1
|
||||
[6] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ]
|
||||
to:main::@3
|
||||
|
||||
CALL GRAPH
|
||||
Calls in [] to 0:main
|
||||
@ -500,19 +532,19 @@ DOMINATORS
|
||||
main dominated by @begin main
|
||||
main::@1 dominated by @begin main::@1 main
|
||||
main::@3 dominated by @begin main::@1 main::@3 main
|
||||
main::@return dominated by main::@return @begin main::@1 main::@3 main
|
||||
main::@2 dominated by @begin main::@2 main::@1 main
|
||||
main::@return dominated by main::@return @begin main::@2 main::@1 main
|
||||
|
||||
Found back edge: Loop head: main::@1 tails: main::@3 blocks: null
|
||||
Populated: Loop head: main::@1 tails: main::@3 blocks: main::@3 main::@1 main::@2
|
||||
Found back edge: Loop head: main::@1 tails: main::@2 blocks: null
|
||||
Populated: Loop head: main::@1 tails: main::@2 blocks: main::@2 main::@1 main::@3
|
||||
NATURAL LOOPS
|
||||
Loop head: main::@1 tails: main::@3 blocks: main::@3 main::@1 main::@2
|
||||
Loop head: main::@1 tails: main::@2 blocks: main::@2 main::@1 main::@3
|
||||
|
||||
Found 0 loops in scope []
|
||||
Found 1 loops in scope [main]
|
||||
Loop head: main::@1 tails: main::@3 blocks: main::@3 main::@1 main::@2
|
||||
Loop head: main::@1 tails: main::@2 blocks: main::@2 main::@1 main::@3
|
||||
NATURAL LOOPS WITH DEPTH
|
||||
Loop head: main::@1 tails: main::@3 blocks: main::@3 main::@1 main::@2 depth: 1
|
||||
Loop head: main::@1 tails: main::@2 blocks: main::@2 main::@1 main::@3 depth: 1
|
||||
|
||||
|
||||
VARIABLE REGISTER WEIGHTS
|
||||
@ -543,36 +575,36 @@ main: {
|
||||
lda #$0
|
||||
sta $2
|
||||
jmp b1
|
||||
//SEG6 [1] phi from main::@3 to main::@1
|
||||
b1_from_b3:
|
||||
//SEG6 [1] phi from main::@2 to main::@1
|
||||
b1_from_b2:
|
||||
//SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy
|
||||
jmp b1
|
||||
//SEG8 main::@1
|
||||
b1:
|
||||
//SEG9 [2] if((byte) main::i#2<(byte) 50) goto main::@2 [ main::i#2 ] -- zpby1_lt_coby1_then_la1
|
||||
//SEG9 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- zpby1_ge_coby1_then_la1
|
||||
lda $2
|
||||
cmp #$32
|
||||
bcc b2
|
||||
bcs b2
|
||||
jmp b3
|
||||
//SEG10 main::@3
|
||||
b3:
|
||||
//SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- zpby1=_inc_zpby1
|
||||
inc $2
|
||||
//SEG12 [4] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- zpby1_lt_coby1_then_la1
|
||||
lda $2
|
||||
cmp #$64
|
||||
bcc b1_from_b3
|
||||
jmp breturn
|
||||
//SEG13 main::@return
|
||||
breturn:
|
||||
//SEG14 [5] return [ ]
|
||||
rts
|
||||
//SEG15 main::@2
|
||||
b2:
|
||||
//SEG16 [6] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=zpby1
|
||||
//SEG11 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=zpby1
|
||||
lda $2
|
||||
sta $400
|
||||
jmp b3
|
||||
jmp b2
|
||||
//SEG12 main::@2
|
||||
b2:
|
||||
//SEG13 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- zpby1=_inc_zpby1
|
||||
inc $2
|
||||
//SEG14 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- zpby1_lt_coby1_then_la1
|
||||
lda $2
|
||||
cmp #$64
|
||||
bcc b1_from_b2
|
||||
jmp breturn
|
||||
//SEG15 main::@return
|
||||
breturn:
|
||||
//SEG16 [6] return [ ]
|
||||
rts
|
||||
}
|
||||
|
||||
REGISTER UPLIFT POTENTIAL REGISTERS
|
||||
@ -587,6 +619,7 @@ Uplifting [] best 335 combination
|
||||
Removing instruction jmp bend
|
||||
Removing instruction jmp b1
|
||||
Removing instruction jmp b3
|
||||
Removing instruction jmp b2
|
||||
Removing instruction jmp breturn
|
||||
Succesful ASM optimization Pass5NextJumpElimination
|
||||
ASSEMBLER
|
||||
@ -603,34 +636,33 @@ main: {
|
||||
//SEG5 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1
|
||||
ldx #$0
|
||||
jmp b1
|
||||
//SEG6 [1] phi from main::@3 to main::@1
|
||||
b1_from_b3:
|
||||
//SEG6 [1] phi from main::@2 to main::@1
|
||||
b1_from_b2:
|
||||
//SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy
|
||||
//SEG8 main::@1
|
||||
b1:
|
||||
//SEG9 [2] if((byte) main::i#2<(byte) 50) goto main::@2 [ main::i#2 ] -- xby_lt_coby1_then_la1
|
||||
//SEG9 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1
|
||||
cpx #$32
|
||||
bcc b2
|
||||
bcs b2
|
||||
//SEG10 main::@3
|
||||
b3:
|
||||
//SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby
|
||||
inx
|
||||
//SEG12 [4] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1
|
||||
cpx #$64
|
||||
bcc b1_from_b3
|
||||
//SEG13 main::@return
|
||||
breturn:
|
||||
//SEG14 [5] return [ ]
|
||||
rts
|
||||
//SEG15 main::@2
|
||||
b2:
|
||||
//SEG16 [6] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby
|
||||
//SEG11 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby
|
||||
stx $400
|
||||
jmp b3
|
||||
//SEG12 main::@2
|
||||
b2:
|
||||
//SEG13 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby
|
||||
inx
|
||||
//SEG14 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1
|
||||
cpx #$64
|
||||
bcc b1_from_b2
|
||||
//SEG15 main::@return
|
||||
breturn:
|
||||
//SEG16 [6] return [ ]
|
||||
rts
|
||||
}
|
||||
|
||||
Replacing label b1_from_b3 with b1
|
||||
Removing instruction b1_from_b3:
|
||||
Replacing label b1_from_b2 with b1
|
||||
Removing instruction b1_from_b2:
|
||||
Succesful ASM optimization Pass5RedundantLabelElimination
|
||||
ASSEMBLER
|
||||
//SEG0 @begin
|
||||
@ -646,34 +678,34 @@ main: {
|
||||
//SEG5 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1
|
||||
ldx #$0
|
||||
jmp b1
|
||||
//SEG6 [1] phi from main::@3 to main::@1
|
||||
//SEG6 [1] phi from main::@2 to main::@1
|
||||
//SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy
|
||||
//SEG8 main::@1
|
||||
b1:
|
||||
//SEG9 [2] if((byte) main::i#2<(byte) 50) goto main::@2 [ main::i#2 ] -- xby_lt_coby1_then_la1
|
||||
//SEG9 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1
|
||||
cpx #$32
|
||||
bcc b2
|
||||
bcs b2
|
||||
//SEG10 main::@3
|
||||
b3:
|
||||
//SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby
|
||||
//SEG11 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby
|
||||
stx $400
|
||||
//SEG12 main::@2
|
||||
b2:
|
||||
//SEG13 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby
|
||||
inx
|
||||
//SEG12 [4] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1
|
||||
//SEG14 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1
|
||||
cpx #$64
|
||||
bcc b1
|
||||
//SEG13 main::@return
|
||||
//SEG15 main::@return
|
||||
breturn:
|
||||
//SEG14 [5] return [ ]
|
||||
//SEG16 [6] return [ ]
|
||||
rts
|
||||
//SEG15 main::@2
|
||||
b2:
|
||||
//SEG16 [6] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby
|
||||
stx $400
|
||||
jmp b3
|
||||
}
|
||||
|
||||
Removing instruction bbegin:
|
||||
Removing instruction bend:
|
||||
Removing instruction b1_from_main:
|
||||
Removing instruction b3:
|
||||
Removing instruction breturn:
|
||||
Succesful ASM optimization Pass5UnusedLabelElimination
|
||||
ASSEMBLER
|
||||
@ -687,28 +719,26 @@ main: {
|
||||
//SEG5 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1
|
||||
ldx #$0
|
||||
jmp b1
|
||||
//SEG6 [1] phi from main::@3 to main::@1
|
||||
//SEG6 [1] phi from main::@2 to main::@1
|
||||
//SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy
|
||||
//SEG8 main::@1
|
||||
b1:
|
||||
//SEG9 [2] if((byte) main::i#2<(byte) 50) goto main::@2 [ main::i#2 ] -- xby_lt_coby1_then_la1
|
||||
//SEG9 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1
|
||||
cpx #$32
|
||||
bcc b2
|
||||
bcs b2
|
||||
//SEG10 main::@3
|
||||
b3:
|
||||
//SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby
|
||||
//SEG11 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby
|
||||
stx $400
|
||||
//SEG12 main::@2
|
||||
b2:
|
||||
//SEG13 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby
|
||||
inx
|
||||
//SEG12 [4] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1
|
||||
//SEG14 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1
|
||||
cpx #$64
|
||||
bcc b1
|
||||
//SEG13 main::@return
|
||||
//SEG14 [5] return [ ]
|
||||
//SEG15 main::@return
|
||||
//SEG16 [6] return [ ]
|
||||
rts
|
||||
//SEG15 main::@2
|
||||
b2:
|
||||
//SEG16 [6] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby
|
||||
stx $400
|
||||
jmp b3
|
||||
}
|
||||
|
||||
Removing instruction jmp b1
|
||||
@ -723,28 +753,26 @@ main: {
|
||||
//SEG4 [1] phi from main to main::@1
|
||||
//SEG5 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1
|
||||
ldx #$0
|
||||
//SEG6 [1] phi from main::@3 to main::@1
|
||||
//SEG6 [1] phi from main::@2 to main::@1
|
||||
//SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy
|
||||
//SEG8 main::@1
|
||||
b1:
|
||||
//SEG9 [2] if((byte) main::i#2<(byte) 50) goto main::@2 [ main::i#2 ] -- xby_lt_coby1_then_la1
|
||||
//SEG9 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1
|
||||
cpx #$32
|
||||
bcc b2
|
||||
bcs b2
|
||||
//SEG10 main::@3
|
||||
b3:
|
||||
//SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby
|
||||
//SEG11 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby
|
||||
stx $400
|
||||
//SEG12 main::@2
|
||||
b2:
|
||||
//SEG13 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby
|
||||
inx
|
||||
//SEG12 [4] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1
|
||||
//SEG14 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1
|
||||
cpx #$64
|
||||
bcc b1
|
||||
//SEG13 main::@return
|
||||
//SEG14 [5] return [ ]
|
||||
//SEG15 main::@return
|
||||
//SEG16 [6] return [ ]
|
||||
rts
|
||||
//SEG15 main::@2
|
||||
b2:
|
||||
//SEG16 [6] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby
|
||||
stx $400
|
||||
jmp b3
|
||||
}
|
||||
|
||||
FINAL SYMBOL TABLE
|
||||
@ -772,27 +800,25 @@ main: {
|
||||
//SEG4 [1] phi from main to main::@1
|
||||
//SEG5 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1
|
||||
ldx #$0
|
||||
//SEG6 [1] phi from main::@3 to main::@1
|
||||
//SEG6 [1] phi from main::@2 to main::@1
|
||||
//SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy
|
||||
//SEG8 main::@1
|
||||
b1:
|
||||
//SEG9 [2] if((byte) main::i#2<(byte) 50) goto main::@2 [ main::i#2 ] -- xby_lt_coby1_then_la1
|
||||
//SEG9 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1
|
||||
cpx #$32
|
||||
bcc b2
|
||||
bcs b2
|
||||
//SEG10 main::@3
|
||||
b3:
|
||||
//SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby
|
||||
//SEG11 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby
|
||||
stx $400
|
||||
//SEG12 main::@2
|
||||
b2:
|
||||
//SEG13 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby
|
||||
inx
|
||||
//SEG12 [4] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1
|
||||
//SEG14 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1
|
||||
cpx #$64
|
||||
bcc b1
|
||||
//SEG13 main::@return
|
||||
//SEG14 [5] return [ ]
|
||||
//SEG15 main::@return
|
||||
//SEG16 [6] return [ ]
|
||||
rts
|
||||
//SEG15 main::@2
|
||||
b2:
|
||||
//SEG16 [6] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby
|
||||
stx $400
|
||||
jmp b3
|
||||
}
|
||||
|
||||
|
||||
@ -2,15 +2,12 @@
|
||||
ldx #$a
|
||||
b1:
|
||||
cpx #$5
|
||||
beq !+
|
||||
bcs b2
|
||||
!:
|
||||
b3:
|
||||
dex
|
||||
cpx #$0
|
||||
bne b1
|
||||
b2:
|
||||
bcc b2
|
||||
beq b2
|
||||
stx $ff
|
||||
clc
|
||||
adc $ff
|
||||
jmp b3
|
||||
b2:
|
||||
dex
|
||||
cpx #$0
|
||||
bne b1
|
||||
|
||||
@ -1,16 +1,16 @@
|
||||
@begin: scope:[] from
|
||||
to:@1
|
||||
@1: scope:[] from @3 @begin
|
||||
[0] (byte) s#2 ← phi( @3/(byte) s#4 @begin/(byte) 0 ) [ i#2 s#2 ]
|
||||
[0] (byte) i#2 ← phi( @3/(byte) i#1 @begin/(byte) 10 ) [ i#2 s#2 ]
|
||||
[1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ]
|
||||
@1: scope:[] from @2 @begin
|
||||
[0] (byte) s#2 ← phi( @2/(byte) s#4 @begin/(byte) 0 ) [ i#2 s#2 ]
|
||||
[0] (byte) i#2 ← phi( @2/(byte) i#1 @begin/(byte) 10 ) [ i#2 s#2 ]
|
||||
[1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ]
|
||||
to:@3
|
||||
@3: scope:[] from @1 @2
|
||||
[2] (byte) s#4 ← phi( @1/(byte) s#2 @2/(byte) s#1 ) [ s#4 i#2 ]
|
||||
[3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ]
|
||||
[4] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ]
|
||||
@3: scope:[] from @1
|
||||
[2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ]
|
||||
to:@2
|
||||
@2: scope:[] from @1 @3
|
||||
[3] (byte) s#4 ← phi( @1/(byte) s#2 @3/(byte) s#1 ) [ s#4 i#2 ]
|
||||
[4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ]
|
||||
[5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ]
|
||||
to:@end
|
||||
@end: scope:[] from @3
|
||||
@2: scope:[] from @1
|
||||
[5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ]
|
||||
to:@3
|
||||
@end: scope:[] from @2
|
||||
|
||||
@ -12,23 +12,22 @@ PROGRAM
|
||||
(byte) s ← (byte) 0
|
||||
@1:
|
||||
(boolean~) $0 ← (byte) i > (byte) 5
|
||||
if((boolean~) $0) goto @2
|
||||
goto @3
|
||||
(boolean~) $1 ← ! (boolean~) $0
|
||||
if((boolean~) $1) goto @2
|
||||
(byte~) $2 ← (byte) s + (byte) i
|
||||
(byte) s ← (byte~) $2
|
||||
@2:
|
||||
(byte~) $1 ← (byte) s + (byte) i
|
||||
(byte) s ← (byte~) $1
|
||||
@3:
|
||||
(byte) i ← -- (byte) i
|
||||
(boolean~) $2 ← (byte) i > (byte) 0
|
||||
if((boolean~) $2) goto @1
|
||||
(boolean~) $3 ← (byte) i > (byte) 0
|
||||
if((boolean~) $3) goto @1
|
||||
|
||||
SYMBOLS
|
||||
(boolean~) $0
|
||||
(byte~) $1
|
||||
(boolean~) $2
|
||||
(boolean~) $1
|
||||
(byte~) $2
|
||||
(boolean~) $3
|
||||
(label) @1
|
||||
(label) @2
|
||||
(label) @3
|
||||
(byte) i
|
||||
(byte) s
|
||||
|
||||
@ -37,49 +36,45 @@ INITIAL CONTROL FLOW GRAPH
|
||||
(byte) i ← (byte) 10
|
||||
(byte) s ← (byte) 0
|
||||
to:@1
|
||||
@1: scope:[] from @3 @begin
|
||||
@1: scope:[] from @2 @begin
|
||||
(boolean~) $0 ← (byte) i > (byte) 5
|
||||
if((boolean~) $0) goto @2
|
||||
to:@4
|
||||
@2: scope:[] from @1 @5
|
||||
(byte~) $1 ← (byte) s + (byte) i
|
||||
(byte) s ← (byte~) $1
|
||||
(boolean~) $1 ← ! (boolean~) $0
|
||||
if((boolean~) $1) goto @2
|
||||
to:@3
|
||||
@4: scope:[] from @1
|
||||
to:@3
|
||||
@3: scope:[] from @2 @4
|
||||
@2: scope:[] from @1 @3
|
||||
(byte) i ← -- (byte) i
|
||||
(boolean~) $2 ← (byte) i > (byte) 0
|
||||
if((boolean~) $2) goto @1
|
||||
to:@6
|
||||
@5: scope:[] from
|
||||
(boolean~) $3 ← (byte) i > (byte) 0
|
||||
if((boolean~) $3) goto @1
|
||||
to:@4
|
||||
@3: scope:[] from @1
|
||||
(byte~) $2 ← (byte) s + (byte) i
|
||||
(byte) s ← (byte~) $2
|
||||
to:@2
|
||||
@6: scope:[] from @3
|
||||
@4: scope:[] from @2
|
||||
to:@end
|
||||
@end: scope:[] from @6
|
||||
@end: scope:[] from @4
|
||||
|
||||
Removing empty block @4
|
||||
Removing empty block @5
|
||||
Removing empty block @6
|
||||
CONTROL FLOW GRAPH
|
||||
@begin: scope:[] from
|
||||
(byte) i ← (byte) 10
|
||||
(byte) s ← (byte) 0
|
||||
to:@1
|
||||
@1: scope:[] from @3 @begin
|
||||
@1: scope:[] from @2 @begin
|
||||
(boolean~) $0 ← (byte) i > (byte) 5
|
||||
if((boolean~) $0) goto @2
|
||||
(boolean~) $1 ← ! (boolean~) $0
|
||||
if((boolean~) $1) goto @2
|
||||
to:@3
|
||||
@2: scope:[] from @1
|
||||
(byte~) $1 ← (byte) s + (byte) i
|
||||
(byte) s ← (byte~) $1
|
||||
to:@3
|
||||
@3: scope:[] from @1 @2
|
||||
@2: scope:[] from @1 @3
|
||||
(byte) i ← -- (byte) i
|
||||
(boolean~) $2 ← (byte) i > (byte) 0
|
||||
if((boolean~) $2) goto @1
|
||||
(boolean~) $3 ← (byte) i > (byte) 0
|
||||
if((boolean~) $3) goto @1
|
||||
to:@end
|
||||
@end: scope:[] from @3
|
||||
@3: scope:[] from @1
|
||||
(byte~) $2 ← (byte) s + (byte) i
|
||||
(byte) s ← (byte~) $2
|
||||
to:@2
|
||||
@end: scope:[] from @2
|
||||
|
||||
PROCEDURE MODIFY VARIABLE ANALYSIS
|
||||
|
||||
@ -88,20 +83,21 @@ CONTROL FLOW GRAPH WITH ASSIGNMENT CALL
|
||||
(byte) i ← (byte) 10
|
||||
(byte) s ← (byte) 0
|
||||
to:@1
|
||||
@1: scope:[] from @3 @begin
|
||||
@1: scope:[] from @2 @begin
|
||||
(boolean~) $0 ← (byte) i > (byte) 5
|
||||
if((boolean~) $0) goto @2
|
||||
(boolean~) $1 ← ! (boolean~) $0
|
||||
if((boolean~) $1) goto @2
|
||||
to:@3
|
||||
@2: scope:[] from @1
|
||||
(byte~) $1 ← (byte) s + (byte) i
|
||||
(byte) s ← (byte~) $1
|
||||
to:@3
|
||||
@3: scope:[] from @1 @2
|
||||
@2: scope:[] from @1 @3
|
||||
(byte) i ← -- (byte) i
|
||||
(boolean~) $2 ← (byte) i > (byte) 0
|
||||
if((boolean~) $2) goto @1
|
||||
(boolean~) $3 ← (byte) i > (byte) 0
|
||||
if((boolean~) $3) goto @1
|
||||
to:@end
|
||||
@end: scope:[] from @3
|
||||
@3: scope:[] from @1
|
||||
(byte~) $2 ← (byte) s + (byte) i
|
||||
(byte) s ← (byte~) $2
|
||||
to:@2
|
||||
@end: scope:[] from @2
|
||||
|
||||
Completing Phi functions...
|
||||
Completing Phi functions...
|
||||
@ -111,52 +107,54 @@ CONTROL FLOW GRAPH SSA
|
||||
(byte) i#0 ← (byte) 10
|
||||
(byte) s#0 ← (byte) 0
|
||||
to:@1
|
||||
@1: scope:[] from @3 @begin
|
||||
(byte) s#3 ← phi( @3/(byte) s#4 @begin/(byte) s#0 )
|
||||
(byte) i#2 ← phi( @3/(byte) i#1 @begin/(byte) i#0 )
|
||||
@1: scope:[] from @2 @begin
|
||||
(byte) s#3 ← phi( @2/(byte) s#4 @begin/(byte) s#0 )
|
||||
(byte) i#2 ← phi( @2/(byte) i#1 @begin/(byte) i#0 )
|
||||
(boolean~) $0 ← (byte) i#2 > (byte) 5
|
||||
if((boolean~) $0) goto @2
|
||||
(boolean~) $1 ← ! (boolean~) $0
|
||||
if((boolean~) $1) goto @2
|
||||
to:@3
|
||||
@2: scope:[] from @1
|
||||
(byte) i#3 ← phi( @1/(byte) i#2 )
|
||||
(byte) s#2 ← phi( @1/(byte) s#3 )
|
||||
(byte~) $1 ← (byte) s#2 + (byte) i#3
|
||||
(byte) s#1 ← (byte~) $1
|
||||
to:@3
|
||||
@3: scope:[] from @1 @2
|
||||
(byte) s#4 ← phi( @1/(byte) s#3 @2/(byte) s#1 )
|
||||
(byte) i#4 ← phi( @1/(byte) i#2 @2/(byte) i#3 )
|
||||
(byte) i#1 ← -- (byte) i#4
|
||||
(boolean~) $2 ← (byte) i#1 > (byte) 0
|
||||
if((boolean~) $2) goto @1
|
||||
@2: scope:[] from @1 @3
|
||||
(byte) s#4 ← phi( @1/(byte) s#3 @3/(byte) s#1 )
|
||||
(byte) i#3 ← phi( @1/(byte) i#2 @3/(byte) i#4 )
|
||||
(byte) i#1 ← -- (byte) i#3
|
||||
(boolean~) $3 ← (byte) i#1 > (byte) 0
|
||||
if((boolean~) $3) goto @1
|
||||
to:@end
|
||||
@end: scope:[] from @3
|
||||
@3: scope:[] from @1
|
||||
(byte) i#4 ← phi( @1/(byte) i#2 )
|
||||
(byte) s#2 ← phi( @1/(byte) s#3 )
|
||||
(byte~) $2 ← (byte) s#2 + (byte) i#4
|
||||
(byte) s#1 ← (byte~) $2
|
||||
to:@2
|
||||
@end: scope:[] from @2
|
||||
|
||||
CONTROL FLOW GRAPH WITH ASSIGNMENT CALL & RETURN
|
||||
@begin: scope:[] from
|
||||
(byte) i#0 ← (byte) 10
|
||||
(byte) s#0 ← (byte) 0
|
||||
to:@1
|
||||
@1: scope:[] from @3 @begin
|
||||
(byte) s#3 ← phi( @3/(byte) s#4 @begin/(byte) s#0 )
|
||||
(byte) i#2 ← phi( @3/(byte) i#1 @begin/(byte) i#0 )
|
||||
@1: scope:[] from @2 @begin
|
||||
(byte) s#3 ← phi( @2/(byte) s#4 @begin/(byte) s#0 )
|
||||
(byte) i#2 ← phi( @2/(byte) i#1 @begin/(byte) i#0 )
|
||||
(boolean~) $0 ← (byte) i#2 > (byte) 5
|
||||
if((boolean~) $0) goto @2
|
||||
(boolean~) $1 ← ! (boolean~) $0
|
||||
if((boolean~) $1) goto @2
|
||||
to:@3
|
||||
@2: scope:[] from @1
|
||||
(byte) i#3 ← phi( @1/(byte) i#2 )
|
||||
(byte) s#2 ← phi( @1/(byte) s#3 )
|
||||
(byte~) $1 ← (byte) s#2 + (byte) i#3
|
||||
(byte) s#1 ← (byte~) $1
|
||||
to:@3
|
||||
@3: scope:[] from @1 @2
|
||||
(byte) s#4 ← phi( @1/(byte) s#3 @2/(byte) s#1 )
|
||||
(byte) i#4 ← phi( @1/(byte) i#2 @2/(byte) i#3 )
|
||||
(byte) i#1 ← -- (byte) i#4
|
||||
(boolean~) $2 ← (byte) i#1 > (byte) 0
|
||||
if((boolean~) $2) goto @1
|
||||
@2: scope:[] from @1 @3
|
||||
(byte) s#4 ← phi( @1/(byte) s#3 @3/(byte) s#1 )
|
||||
(byte) i#3 ← phi( @1/(byte) i#2 @3/(byte) i#4 )
|
||||
(byte) i#1 ← -- (byte) i#3
|
||||
(boolean~) $3 ← (byte) i#1 > (byte) 0
|
||||
if((boolean~) $3) goto @1
|
||||
to:@end
|
||||
@end: scope:[] from @3
|
||||
@3: scope:[] from @1
|
||||
(byte) i#4 ← phi( @1/(byte) i#2 )
|
||||
(byte) s#2 ← phi( @1/(byte) s#3 )
|
||||
(byte~) $2 ← (byte) s#2 + (byte) i#4
|
||||
(byte) s#1 ← (byte~) $2
|
||||
to:@2
|
||||
@end: scope:[] from @2
|
||||
|
||||
Constant (byte) i#0 (byte) 10
|
||||
Constant (byte) s#0 (byte) 0
|
||||
@ -164,124 +162,151 @@ Succesful SSA optimization Pass2ConstantPropagation
|
||||
CONTROL FLOW GRAPH
|
||||
@begin: scope:[] from
|
||||
to:@1
|
||||
@1: scope:[] from @3 @begin
|
||||
(byte) s#3 ← phi( @3/(byte) s#4 @begin/(byte) 0 )
|
||||
(byte) i#2 ← phi( @3/(byte) i#1 @begin/(byte) 10 )
|
||||
@1: scope:[] from @2 @begin
|
||||
(byte) s#3 ← phi( @2/(byte) s#4 @begin/(byte) 0 )
|
||||
(byte) i#2 ← phi( @2/(byte) i#1 @begin/(byte) 10 )
|
||||
(boolean~) $0 ← (byte) i#2 > (byte) 5
|
||||
if((boolean~) $0) goto @2
|
||||
(boolean~) $1 ← ! (boolean~) $0
|
||||
if((boolean~) $1) goto @2
|
||||
to:@3
|
||||
@2: scope:[] from @1
|
||||
(byte) i#3 ← phi( @1/(byte) i#2 )
|
||||
(byte) s#2 ← phi( @1/(byte) s#3 )
|
||||
(byte~) $1 ← (byte) s#2 + (byte) i#3
|
||||
(byte) s#1 ← (byte~) $1
|
||||
to:@3
|
||||
@3: scope:[] from @1 @2
|
||||
(byte) s#4 ← phi( @1/(byte) s#3 @2/(byte) s#1 )
|
||||
(byte) i#4 ← phi( @1/(byte) i#2 @2/(byte) i#3 )
|
||||
(byte) i#1 ← -- (byte) i#4
|
||||
(boolean~) $2 ← (byte) i#1 > (byte) 0
|
||||
if((boolean~) $2) goto @1
|
||||
@2: scope:[] from @1 @3
|
||||
(byte) s#4 ← phi( @1/(byte) s#3 @3/(byte) s#1 )
|
||||
(byte) i#3 ← phi( @1/(byte) i#2 @3/(byte) i#4 )
|
||||
(byte) i#1 ← -- (byte) i#3
|
||||
(boolean~) $3 ← (byte) i#1 > (byte) 0
|
||||
if((boolean~) $3) goto @1
|
||||
to:@end
|
||||
@end: scope:[] from @3
|
||||
@3: scope:[] from @1
|
||||
(byte) i#4 ← phi( @1/(byte) i#2 )
|
||||
(byte) s#2 ← phi( @1/(byte) s#3 )
|
||||
(byte~) $2 ← (byte) s#2 + (byte) i#4
|
||||
(byte) s#1 ← (byte~) $2
|
||||
to:@2
|
||||
@end: scope:[] from @2
|
||||
|
||||
Inversing boolean not (boolean~) $1 ← (byte) i#2 <= (byte) 5 from (boolean~) $0 ← (byte) i#2 > (byte) 5
|
||||
Succesful SSA optimization Pass2UnaryNotSimplification
|
||||
CONTROL FLOW GRAPH
|
||||
@begin: scope:[] from
|
||||
to:@1
|
||||
@1: scope:[] from @2 @begin
|
||||
(byte) s#3 ← phi( @2/(byte) s#4 @begin/(byte) 0 )
|
||||
(byte) i#2 ← phi( @2/(byte) i#1 @begin/(byte) 10 )
|
||||
(boolean~) $1 ← (byte) i#2 <= (byte) 5
|
||||
if((boolean~) $1) goto @2
|
||||
to:@3
|
||||
@2: scope:[] from @1 @3
|
||||
(byte) s#4 ← phi( @1/(byte) s#3 @3/(byte) s#1 )
|
||||
(byte) i#3 ← phi( @1/(byte) i#2 @3/(byte) i#4 )
|
||||
(byte) i#1 ← -- (byte) i#3
|
||||
(boolean~) $3 ← (byte) i#1 > (byte) 0
|
||||
if((boolean~) $3) goto @1
|
||||
to:@end
|
||||
@3: scope:[] from @1
|
||||
(byte) i#4 ← phi( @1/(byte) i#2 )
|
||||
(byte) s#2 ← phi( @1/(byte) s#3 )
|
||||
(byte~) $2 ← (byte) s#2 + (byte) i#4
|
||||
(byte) s#1 ← (byte~) $2
|
||||
to:@2
|
||||
@end: scope:[] from @2
|
||||
|
||||
Alias (byte) s#2 = (byte) s#3
|
||||
Alias (byte) i#2 = (byte) i#3
|
||||
Alias (byte) s#1 = (byte~) $1
|
||||
Alias (byte) i#2 = (byte) i#4
|
||||
Alias (byte) s#1 = (byte~) $2
|
||||
Succesful SSA optimization Pass2AliasElimination
|
||||
CONTROL FLOW GRAPH
|
||||
@begin: scope:[] from
|
||||
to:@1
|
||||
@1: scope:[] from @3 @begin
|
||||
(byte) s#2 ← phi( @3/(byte) s#4 @begin/(byte) 0 )
|
||||
(byte) i#2 ← phi( @3/(byte) i#1 @begin/(byte) 10 )
|
||||
(boolean~) $0 ← (byte) i#2 > (byte) 5
|
||||
if((boolean~) $0) goto @2
|
||||
@1: scope:[] from @2 @begin
|
||||
(byte) s#2 ← phi( @2/(byte) s#4 @begin/(byte) 0 )
|
||||
(byte) i#2 ← phi( @2/(byte) i#1 @begin/(byte) 10 )
|
||||
(boolean~) $1 ← (byte) i#2 <= (byte) 5
|
||||
if((boolean~) $1) goto @2
|
||||
to:@3
|
||||
@2: scope:[] from @1
|
||||
(byte) s#1 ← (byte) s#2 + (byte) i#2
|
||||
to:@3
|
||||
@3: scope:[] from @1 @2
|
||||
(byte) s#4 ← phi( @1/(byte) s#2 @2/(byte) s#1 )
|
||||
(byte) i#4 ← phi( @1/(byte) i#2 @2/(byte) i#2 )
|
||||
(byte) i#1 ← -- (byte) i#4
|
||||
(boolean~) $2 ← (byte) i#1 > (byte) 0
|
||||
if((boolean~) $2) goto @1
|
||||
@2: scope:[] from @1 @3
|
||||
(byte) s#4 ← phi( @1/(byte) s#2 @3/(byte) s#1 )
|
||||
(byte) i#3 ← phi( @1/(byte) i#2 @3/(byte) i#2 )
|
||||
(byte) i#1 ← -- (byte) i#3
|
||||
(boolean~) $3 ← (byte) i#1 > (byte) 0
|
||||
if((boolean~) $3) goto @1
|
||||
to:@end
|
||||
@end: scope:[] from @3
|
||||
@3: scope:[] from @1
|
||||
(byte) s#1 ← (byte) s#2 + (byte) i#2
|
||||
to:@2
|
||||
@end: scope:[] from @2
|
||||
|
||||
Redundant Phi (byte) i#4 (byte) i#2
|
||||
Redundant Phi (byte) i#3 (byte) i#2
|
||||
Succesful SSA optimization Pass2RedundantPhiElimination
|
||||
CONTROL FLOW GRAPH
|
||||
@begin: scope:[] from
|
||||
to:@1
|
||||
@1: scope:[] from @3 @begin
|
||||
(byte) s#2 ← phi( @3/(byte) s#4 @begin/(byte) 0 )
|
||||
(byte) i#2 ← phi( @3/(byte) i#1 @begin/(byte) 10 )
|
||||
(boolean~) $0 ← (byte) i#2 > (byte) 5
|
||||
if((boolean~) $0) goto @2
|
||||
@1: scope:[] from @2 @begin
|
||||
(byte) s#2 ← phi( @2/(byte) s#4 @begin/(byte) 0 )
|
||||
(byte) i#2 ← phi( @2/(byte) i#1 @begin/(byte) 10 )
|
||||
(boolean~) $1 ← (byte) i#2 <= (byte) 5
|
||||
if((boolean~) $1) goto @2
|
||||
to:@3
|
||||
@2: scope:[] from @1
|
||||
(byte) s#1 ← (byte) s#2 + (byte) i#2
|
||||
to:@3
|
||||
@3: scope:[] from @1 @2
|
||||
(byte) s#4 ← phi( @1/(byte) s#2 @2/(byte) s#1 )
|
||||
@2: scope:[] from @1 @3
|
||||
(byte) s#4 ← phi( @1/(byte) s#2 @3/(byte) s#1 )
|
||||
(byte) i#1 ← -- (byte) i#2
|
||||
(boolean~) $2 ← (byte) i#1 > (byte) 0
|
||||
if((boolean~) $2) goto @1
|
||||
(boolean~) $3 ← (byte) i#1 > (byte) 0
|
||||
if((boolean~) $3) goto @1
|
||||
to:@end
|
||||
@end: scope:[] from @3
|
||||
@3: scope:[] from @1
|
||||
(byte) s#1 ← (byte) s#2 + (byte) i#2
|
||||
to:@2
|
||||
@end: scope:[] from @2
|
||||
|
||||
Simple Condition (boolean~) $0 if((byte) i#2>(byte) 5) goto @2
|
||||
Simple Condition (boolean~) $2 if((byte) i#1>(byte) 0) goto @1
|
||||
Simple Condition (boolean~) $1 if((byte) i#2<=(byte) 5) goto @2
|
||||
Simple Condition (boolean~) $3 if((byte) i#1>(byte) 0) goto @1
|
||||
Succesful SSA optimization Pass2ConditionalJumpSimplification
|
||||
CONTROL FLOW GRAPH
|
||||
@begin: scope:[] from
|
||||
to:@1
|
||||
@1: scope:[] from @3 @begin
|
||||
(byte) s#2 ← phi( @3/(byte) s#4 @begin/(byte) 0 )
|
||||
(byte) i#2 ← phi( @3/(byte) i#1 @begin/(byte) 10 )
|
||||
if((byte) i#2>(byte) 5) goto @2
|
||||
@1: scope:[] from @2 @begin
|
||||
(byte) s#2 ← phi( @2/(byte) s#4 @begin/(byte) 0 )
|
||||
(byte) i#2 ← phi( @2/(byte) i#1 @begin/(byte) 10 )
|
||||
if((byte) i#2<=(byte) 5) goto @2
|
||||
to:@3
|
||||
@2: scope:[] from @1
|
||||
(byte) s#1 ← (byte) s#2 + (byte) i#2
|
||||
to:@3
|
||||
@3: scope:[] from @1 @2
|
||||
(byte) s#4 ← phi( @1/(byte) s#2 @2/(byte) s#1 )
|
||||
@2: scope:[] from @1 @3
|
||||
(byte) s#4 ← phi( @1/(byte) s#2 @3/(byte) s#1 )
|
||||
(byte) i#1 ← -- (byte) i#2
|
||||
if((byte) i#1>(byte) 0) goto @1
|
||||
to:@end
|
||||
@end: scope:[] from @3
|
||||
@3: scope:[] from @1
|
||||
(byte) s#1 ← (byte) s#2 + (byte) i#2
|
||||
to:@2
|
||||
@end: scope:[] from @2
|
||||
|
||||
Block Sequence Planned @begin @1 @3 @end @2
|
||||
Added new block during phi lifting @7(between @3 and @1)
|
||||
Added new block during phi lifting @8(between @1 and @3)
|
||||
Block Sequence Planned @begin @1 @8 @3 @end @7 @2
|
||||
Block Sequence Planned @begin @1 @3 @2 @end
|
||||
Added new block during phi lifting @5(between @2 and @1)
|
||||
Added new block during phi lifting @6(between @1 and @2)
|
||||
Block Sequence Planned @begin @1 @3 @2 @end @5 @6
|
||||
CONTROL FLOW GRAPH - PHI LIFTED
|
||||
@begin: scope:[] from
|
||||
to:@1
|
||||
@1: scope:[] from @7 @begin
|
||||
(byte) s#2 ← phi( @7/(byte~) s#5 @begin/(byte) 0 )
|
||||
(byte) i#2 ← phi( @7/(byte~) i#5 @begin/(byte) 10 )
|
||||
if((byte) i#2>(byte) 5) goto @2
|
||||
to:@8
|
||||
@8: scope:[] from @1
|
||||
(byte~) s#6 ← (byte) s#2
|
||||
@1: scope:[] from @5 @begin
|
||||
(byte) s#2 ← phi( @5/(byte~) s#5 @begin/(byte) 0 )
|
||||
(byte) i#2 ← phi( @5/(byte~) i#5 @begin/(byte) 10 )
|
||||
if((byte) i#2<=(byte) 5) goto @6
|
||||
to:@3
|
||||
@3: scope:[] from @2 @8
|
||||
(byte) s#4 ← phi( @8/(byte~) s#6 @2/(byte~) s#7 )
|
||||
@3: scope:[] from @1
|
||||
(byte) s#1 ← (byte) s#2 + (byte) i#2
|
||||
(byte~) s#7 ← (byte) s#1
|
||||
to:@2
|
||||
@2: scope:[] from @3 @6
|
||||
(byte) s#4 ← phi( @6/(byte~) s#6 @3/(byte~) s#7 )
|
||||
(byte) i#1 ← -- (byte) i#2
|
||||
if((byte) i#1>(byte) 0) goto @7
|
||||
if((byte) i#1>(byte) 0) goto @5
|
||||
to:@end
|
||||
@end: scope:[] from @3
|
||||
@7: scope:[] from @3
|
||||
@end: scope:[] from @2
|
||||
@5: scope:[] from @2
|
||||
(byte~) i#5 ← (byte) i#1
|
||||
(byte~) s#5 ← (byte) s#4
|
||||
to:@1
|
||||
@2: scope:[] from @1
|
||||
(byte) s#1 ← (byte) s#2 + (byte) i#2
|
||||
(byte~) s#7 ← (byte) s#1
|
||||
to:@3
|
||||
@6: scope:[] from @1
|
||||
(byte~) s#6 ← (byte) s#2
|
||||
to:@2
|
||||
|
||||
Propagating live ranges...
|
||||
Propagating live ranges...
|
||||
@ -290,58 +315,58 @@ Propagating live ranges...
|
||||
CONTROL FLOW GRAPH - LIVE RANGES
|
||||
@begin: scope:[] from
|
||||
to:@1
|
||||
@1: scope:[] from @7 @begin
|
||||
[0] (byte) s#2 ← phi( @7/(byte~) s#5 @begin/(byte) 0 ) [ i#2 s#2 ]
|
||||
[0] (byte) i#2 ← phi( @7/(byte~) i#5 @begin/(byte) 10 ) [ i#2 s#2 ]
|
||||
[1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ]
|
||||
to:@8
|
||||
@8: scope:[] from @1
|
||||
[2] (byte~) s#6 ← (byte) s#2 [ i#2 s#6 ]
|
||||
@1: scope:[] from @5 @begin
|
||||
[0] (byte) s#2 ← phi( @5/(byte~) s#5 @begin/(byte) 0 ) [ i#2 s#2 ]
|
||||
[0] (byte) i#2 ← phi( @5/(byte~) i#5 @begin/(byte) 10 ) [ i#2 s#2 ]
|
||||
[1] if((byte) i#2<=(byte) 5) goto @6 [ i#2 s#2 ]
|
||||
to:@3
|
||||
@3: scope:[] from @2 @8
|
||||
[3] (byte) s#4 ← phi( @8/(byte~) s#6 @2/(byte~) s#7 ) [ i#2 s#4 ]
|
||||
[4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ]
|
||||
[5] if((byte) i#1>(byte) 0) goto @7 [ i#1 s#4 ]
|
||||
@3: scope:[] from @1
|
||||
[2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ]
|
||||
[3] (byte~) s#7 ← (byte) s#1 [ i#2 s#7 ]
|
||||
to:@2
|
||||
@2: scope:[] from @3 @6
|
||||
[4] (byte) s#4 ← phi( @6/(byte~) s#6 @3/(byte~) s#7 ) [ i#2 s#4 ]
|
||||
[5] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ]
|
||||
[6] if((byte) i#1>(byte) 0) goto @5 [ i#1 s#4 ]
|
||||
to:@end
|
||||
@end: scope:[] from @3
|
||||
@7: scope:[] from @3
|
||||
[6] (byte~) i#5 ← (byte) i#1 [ i#5 s#4 ]
|
||||
[7] (byte~) s#5 ← (byte) s#4 [ i#5 s#5 ]
|
||||
@end: scope:[] from @2
|
||||
@5: scope:[] from @2
|
||||
[7] (byte~) i#5 ← (byte) i#1 [ i#5 s#4 ]
|
||||
[8] (byte~) s#5 ← (byte) s#4 [ i#5 s#5 ]
|
||||
to:@1
|
||||
@2: scope:[] from @1
|
||||
[8] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ]
|
||||
[9] (byte~) s#7 ← (byte) s#1 [ i#2 s#7 ]
|
||||
to:@3
|
||||
@6: scope:[] from @1
|
||||
[9] (byte~) s#6 ← (byte) s#2 [ i#2 s#6 ]
|
||||
to:@2
|
||||
|
||||
Created 3 initial phi equivalence classes
|
||||
Coalesced [2] s#6 ← s#2
|
||||
Coalesced [6] i#5 ← i#1
|
||||
Coalesced (already) [7] s#5 ← s#4
|
||||
Coalesced [9] s#7 ← s#1
|
||||
Coalesced [3] s#7 ← s#1
|
||||
Coalesced [7] i#5 ← i#1
|
||||
Coalesced [8] s#5 ← s#4
|
||||
Coalesced (already) [9] s#6 ← s#2
|
||||
Coalesced down to 2 phi equivalence classes
|
||||
Culled Empty Block (label) @8
|
||||
Culled Empty Block (label) @7
|
||||
Block Sequence Planned @begin @1 @3 @end @2
|
||||
Culled Empty Block (label) @5
|
||||
Culled Empty Block (label) @6
|
||||
Block Sequence Planned @begin @1 @3 @2 @end
|
||||
Propagating live ranges...
|
||||
Propagating live ranges...
|
||||
Propagating live ranges...
|
||||
CONTROL FLOW GRAPH - PHI MEM COALESCED
|
||||
@begin: scope:[] from
|
||||
to:@1
|
||||
@1: scope:[] from @3 @begin
|
||||
[0] (byte) s#2 ← phi( @3/(byte) s#4 @begin/(byte) 0 ) [ i#2 s#2 ]
|
||||
[0] (byte) i#2 ← phi( @3/(byte) i#1 @begin/(byte) 10 ) [ i#2 s#2 ]
|
||||
[1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ]
|
||||
@1: scope:[] from @2 @begin
|
||||
[0] (byte) s#2 ← phi( @2/(byte) s#4 @begin/(byte) 0 ) [ i#2 s#2 ]
|
||||
[0] (byte) i#2 ← phi( @2/(byte) i#1 @begin/(byte) 10 ) [ i#2 s#2 ]
|
||||
[1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ]
|
||||
to:@3
|
||||
@3: scope:[] from @1 @2
|
||||
[2] (byte) s#4 ← phi( @1/(byte) s#2 @2/(byte) s#1 ) [ s#4 i#2 ]
|
||||
[3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ]
|
||||
[4] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ]
|
||||
@3: scope:[] from @1
|
||||
[2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ]
|
||||
to:@2
|
||||
@2: scope:[] from @1 @3
|
||||
[3] (byte) s#4 ← phi( @1/(byte) s#2 @3/(byte) s#1 ) [ s#4 i#2 ]
|
||||
[4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ]
|
||||
[5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ]
|
||||
to:@end
|
||||
@end: scope:[] from @3
|
||||
@2: scope:[] from @1
|
||||
[5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ]
|
||||
to:@3
|
||||
@end: scope:[] from @2
|
||||
|
||||
CALL GRAPH
|
||||
|
||||
@ -349,18 +374,18 @@ DOMINATORS
|
||||
@begin dominated by @begin
|
||||
@1 dominated by @1 @begin
|
||||
@3 dominated by @1 @3 @begin
|
||||
@end dominated by @1 @3 @end @begin
|
||||
@2 dominated by @1 @2 @begin
|
||||
@end dominated by @1 @2 @end @begin
|
||||
|
||||
Found back edge: Loop head: @1 tails: @3 blocks: null
|
||||
Populated: Loop head: @1 tails: @3 blocks: @3 @1 @2
|
||||
Found back edge: Loop head: @1 tails: @2 blocks: null
|
||||
Populated: Loop head: @1 tails: @2 blocks: @2 @1 @3
|
||||
NATURAL LOOPS
|
||||
Loop head: @1 tails: @3 blocks: @3 @1 @2
|
||||
Loop head: @1 tails: @2 blocks: @2 @1 @3
|
||||
|
||||
Found 1 loops in scope []
|
||||
Loop head: @1 tails: @3 blocks: @3 @1 @2
|
||||
Loop head: @1 tails: @2 blocks: @2 @1 @3
|
||||
NATURAL LOOPS WITH DEPTH
|
||||
Loop head: @1 tails: @3 blocks: @3 @1 @2 depth: 1
|
||||
Loop head: @1 tails: @2 blocks: @2 @1 @3 depth: 1
|
||||
|
||||
|
||||
VARIABLE REGISTER WEIGHTS
|
||||
@ -392,44 +417,44 @@ b1_from_bbegin:
|
||||
lda #$a
|
||||
sta $2
|
||||
jmp b1
|
||||
//SEG4 [0] phi from @3 to @1
|
||||
b1_from_b3:
|
||||
//SEG4 [0] phi from @2 to @1
|
||||
b1_from_b2:
|
||||
//SEG5 [0] phi (byte) s#2 = (byte) s#4 -- register_copy
|
||||
//SEG6 [0] phi (byte) i#2 = (byte) i#1 -- register_copy
|
||||
jmp b1
|
||||
//SEG7 @1
|
||||
b1:
|
||||
//SEG8 [1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ] -- zpby1_gt_coby1_then_la1
|
||||
//SEG8 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- zpby1_le_coby1_then_la1
|
||||
lda $2
|
||||
cmp #$5
|
||||
beq !+
|
||||
bcs b2
|
||||
!:
|
||||
//SEG9 [2] phi from @1 to @3
|
||||
b3_from_b1:
|
||||
//SEG10 [2] phi (byte) s#4 = (byte) s#2 -- register_copy
|
||||
bcc b2_from_b1
|
||||
beq b2_from_b1
|
||||
jmp b3
|
||||
//SEG11 @3
|
||||
//SEG9 @3
|
||||
b3:
|
||||
//SEG12 [3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- zpby1=_dec_zpby1
|
||||
dec $2
|
||||
//SEG13 [4] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- zpby1_gt_0_then_la1
|
||||
lda $2
|
||||
bne b1_from_b3
|
||||
jmp bend
|
||||
//SEG14 @end
|
||||
bend:
|
||||
//SEG15 @2
|
||||
b2:
|
||||
//SEG16 [5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- zpby1=zpby1_plus_zpby2
|
||||
//SEG10 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- zpby1=zpby1_plus_zpby2
|
||||
lda $3
|
||||
clc
|
||||
adc $2
|
||||
sta $3
|
||||
//SEG17 [2] phi from @2 to @3
|
||||
b3_from_b2:
|
||||
//SEG18 [2] phi (byte) s#4 = (byte) s#1 -- register_copy
|
||||
jmp b3
|
||||
//SEG11 [3] phi from @3 to @2
|
||||
b2_from_b3:
|
||||
//SEG12 [3] phi (byte) s#4 = (byte) s#1 -- register_copy
|
||||
jmp b2
|
||||
//SEG13 [3] phi from @1 to @2
|
||||
b2_from_b1:
|
||||
//SEG14 [3] phi (byte) s#4 = (byte) s#2 -- register_copy
|
||||
jmp b2
|
||||
//SEG15 @2
|
||||
b2:
|
||||
//SEG16 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- zpby1=_dec_zpby1
|
||||
dec $2
|
||||
//SEG17 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- zpby1_gt_0_then_la1
|
||||
lda $2
|
||||
bne b1_from_b2
|
||||
jmp bend
|
||||
//SEG18 @end
|
||||
bend:
|
||||
|
||||
REGISTER UPLIFT POTENTIAL REGISTERS
|
||||
Potential registers zp byte:2 [ i#2 i#1 ] : zp byte:2 , reg byte a , reg byte x , reg byte y ,
|
||||
@ -438,9 +463,10 @@ Potential registers zp byte:3 [ s#2 s#4 s#1 ] : zp byte:3 , reg byte a , reg byt
|
||||
REGISTER UPLIFT SCOPES
|
||||
Uplift Scope [] 49.5: zp byte:3 [ s#2 s#4 s#1 ] 27.5: zp byte:2 [ i#2 i#1 ]
|
||||
|
||||
Uplifting [] best 405 combination reg byte a [ s#2 s#4 s#1 ] reg byte x [ i#2 i#1 ]
|
||||
Uplifting [] best 435 combination reg byte a [ s#2 s#4 s#1 ] reg byte x [ i#2 i#1 ]
|
||||
Removing instruction jmp b1
|
||||
Removing instruction jmp b3
|
||||
Removing instruction jmp b2
|
||||
Removing instruction jmp bend
|
||||
Succesful ASM optimization Pass5NextJumpElimination
|
||||
ASSEMBLER
|
||||
@ -453,45 +479,45 @@ b1_from_bbegin:
|
||||
//SEG3 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1
|
||||
ldx #$a
|
||||
jmp b1
|
||||
//SEG4 [0] phi from @3 to @1
|
||||
b1_from_b3:
|
||||
//SEG4 [0] phi from @2 to @1
|
||||
b1_from_b2:
|
||||
//SEG5 [0] phi (byte) s#2 = (byte) s#4 -- register_copy
|
||||
//SEG6 [0] phi (byte) i#2 = (byte) i#1 -- register_copy
|
||||
//SEG7 @1
|
||||
b1:
|
||||
//SEG8 [1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ] -- xby_gt_coby1_then_la1
|
||||
//SEG8 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1
|
||||
cpx #$5
|
||||
beq !+
|
||||
bcs b2
|
||||
!:
|
||||
//SEG9 [2] phi from @1 to @3
|
||||
b3_from_b1:
|
||||
//SEG10 [2] phi (byte) s#4 = (byte) s#2 -- register_copy
|
||||
//SEG11 @3
|
||||
bcc b2_from_b1
|
||||
beq b2_from_b1
|
||||
//SEG9 @3
|
||||
b3:
|
||||
//SEG12 [3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby
|
||||
dex
|
||||
//SEG13 [4] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1
|
||||
cpx #$0
|
||||
bne b1_from_b3
|
||||
//SEG14 @end
|
||||
bend:
|
||||
//SEG15 @2
|
||||
b2:
|
||||
//SEG16 [5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby
|
||||
//SEG10 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby
|
||||
stx $ff
|
||||
clc
|
||||
adc $ff
|
||||
//SEG17 [2] phi from @2 to @3
|
||||
b3_from_b2:
|
||||
//SEG18 [2] phi (byte) s#4 = (byte) s#1 -- register_copy
|
||||
jmp b3
|
||||
//SEG11 [3] phi from @3 to @2
|
||||
b2_from_b3:
|
||||
//SEG12 [3] phi (byte) s#4 = (byte) s#1 -- register_copy
|
||||
jmp b2
|
||||
//SEG13 [3] phi from @1 to @2
|
||||
b2_from_b1:
|
||||
//SEG14 [3] phi (byte) s#4 = (byte) s#2 -- register_copy
|
||||
//SEG15 @2
|
||||
b2:
|
||||
//SEG16 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby
|
||||
dex
|
||||
//SEG17 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1
|
||||
cpx #$0
|
||||
bne b1_from_b2
|
||||
//SEG18 @end
|
||||
bend:
|
||||
|
||||
Replacing label b1_from_b3 with b1
|
||||
Replacing label b2_from_b1 with b2
|
||||
Replacing label b2_from_b1 with b2
|
||||
Replacing label b1_from_b2 with b1
|
||||
Removing instruction b1_from_bbegin:
|
||||
Removing instruction b1_from_b3:
|
||||
Removing instruction b3_from_b1:
|
||||
Removing instruction bend:
|
||||
Removing instruction b1_from_b2:
|
||||
Removing instruction b2_from_b1:
|
||||
Succesful ASM optimization Pass5RedundantLabelElimination
|
||||
ASSEMBLER
|
||||
//SEG0 @begin
|
||||
@ -502,39 +528,41 @@ bbegin:
|
||||
//SEG3 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1
|
||||
ldx #$a
|
||||
jmp b1
|
||||
//SEG4 [0] phi from @3 to @1
|
||||
//SEG4 [0] phi from @2 to @1
|
||||
//SEG5 [0] phi (byte) s#2 = (byte) s#4 -- register_copy
|
||||
//SEG6 [0] phi (byte) i#2 = (byte) i#1 -- register_copy
|
||||
//SEG7 @1
|
||||
b1:
|
||||
//SEG8 [1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ] -- xby_gt_coby1_then_la1
|
||||
//SEG8 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1
|
||||
cpx #$5
|
||||
beq !+
|
||||
bcs b2
|
||||
!:
|
||||
//SEG9 [2] phi from @1 to @3
|
||||
//SEG10 [2] phi (byte) s#4 = (byte) s#2 -- register_copy
|
||||
//SEG11 @3
|
||||
bcc b2
|
||||
beq b2
|
||||
//SEG9 @3
|
||||
b3:
|
||||
//SEG12 [3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby
|
||||
dex
|
||||
//SEG13 [4] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1
|
||||
cpx #$0
|
||||
bne b1
|
||||
//SEG14 @end
|
||||
//SEG15 @2
|
||||
b2:
|
||||
//SEG16 [5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby
|
||||
//SEG10 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby
|
||||
stx $ff
|
||||
clc
|
||||
adc $ff
|
||||
//SEG17 [2] phi from @2 to @3
|
||||
b3_from_b2:
|
||||
//SEG18 [2] phi (byte) s#4 = (byte) s#1 -- register_copy
|
||||
jmp b3
|
||||
//SEG11 [3] phi from @3 to @2
|
||||
b2_from_b3:
|
||||
//SEG12 [3] phi (byte) s#4 = (byte) s#1 -- register_copy
|
||||
jmp b2
|
||||
//SEG13 [3] phi from @1 to @2
|
||||
//SEG14 [3] phi (byte) s#4 = (byte) s#2 -- register_copy
|
||||
//SEG15 @2
|
||||
b2:
|
||||
//SEG16 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby
|
||||
dex
|
||||
//SEG17 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1
|
||||
cpx #$0
|
||||
bne b1
|
||||
//SEG18 @end
|
||||
bend:
|
||||
|
||||
Removing instruction bbegin:
|
||||
Removing instruction b3_from_b2:
|
||||
Removing instruction b3:
|
||||
Removing instruction b2_from_b3:
|
||||
Removing instruction bend:
|
||||
Succesful ASM optimization Pass5UnusedLabelElimination
|
||||
ASSEMBLER
|
||||
//SEG0 @begin
|
||||
@ -544,37 +572,36 @@ ASSEMBLER
|
||||
//SEG3 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1
|
||||
ldx #$a
|
||||
jmp b1
|
||||
//SEG4 [0] phi from @3 to @1
|
||||
//SEG4 [0] phi from @2 to @1
|
||||
//SEG5 [0] phi (byte) s#2 = (byte) s#4 -- register_copy
|
||||
//SEG6 [0] phi (byte) i#2 = (byte) i#1 -- register_copy
|
||||
//SEG7 @1
|
||||
b1:
|
||||
//SEG8 [1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ] -- xby_gt_coby1_then_la1
|
||||
//SEG8 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1
|
||||
cpx #$5
|
||||
beq !+
|
||||
bcs b2
|
||||
!:
|
||||
//SEG9 [2] phi from @1 to @3
|
||||
//SEG10 [2] phi (byte) s#4 = (byte) s#2 -- register_copy
|
||||
//SEG11 @3
|
||||
b3:
|
||||
//SEG12 [3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby
|
||||
dex
|
||||
//SEG13 [4] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1
|
||||
cpx #$0
|
||||
bne b1
|
||||
//SEG14 @end
|
||||
//SEG15 @2
|
||||
b2:
|
||||
//SEG16 [5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby
|
||||
bcc b2
|
||||
beq b2
|
||||
//SEG9 @3
|
||||
//SEG10 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby
|
||||
stx $ff
|
||||
clc
|
||||
adc $ff
|
||||
//SEG17 [2] phi from @2 to @3
|
||||
//SEG18 [2] phi (byte) s#4 = (byte) s#1 -- register_copy
|
||||
jmp b3
|
||||
//SEG11 [3] phi from @3 to @2
|
||||
//SEG12 [3] phi (byte) s#4 = (byte) s#1 -- register_copy
|
||||
jmp b2
|
||||
//SEG13 [3] phi from @1 to @2
|
||||
//SEG14 [3] phi (byte) s#4 = (byte) s#2 -- register_copy
|
||||
//SEG15 @2
|
||||
b2:
|
||||
//SEG16 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby
|
||||
dex
|
||||
//SEG17 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1
|
||||
cpx #$0
|
||||
bne b1
|
||||
//SEG18 @end
|
||||
|
||||
Removing instruction jmp b1
|
||||
Removing instruction jmp b2
|
||||
Succesful ASM optimization Pass5NextJumpElimination
|
||||
ASSEMBLER
|
||||
//SEG0 @begin
|
||||
@ -583,35 +610,32 @@ ASSEMBLER
|
||||
lda #$0
|
||||
//SEG3 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1
|
||||
ldx #$a
|
||||
//SEG4 [0] phi from @3 to @1
|
||||
//SEG4 [0] phi from @2 to @1
|
||||
//SEG5 [0] phi (byte) s#2 = (byte) s#4 -- register_copy
|
||||
//SEG6 [0] phi (byte) i#2 = (byte) i#1 -- register_copy
|
||||
//SEG7 @1
|
||||
b1:
|
||||
//SEG8 [1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ] -- xby_gt_coby1_then_la1
|
||||
//SEG8 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1
|
||||
cpx #$5
|
||||
beq !+
|
||||
bcs b2
|
||||
!:
|
||||
//SEG9 [2] phi from @1 to @3
|
||||
//SEG10 [2] phi (byte) s#4 = (byte) s#2 -- register_copy
|
||||
//SEG11 @3
|
||||
b3:
|
||||
//SEG12 [3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby
|
||||
dex
|
||||
//SEG13 [4] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1
|
||||
cpx #$0
|
||||
bne b1
|
||||
//SEG14 @end
|
||||
//SEG15 @2
|
||||
b2:
|
||||
//SEG16 [5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby
|
||||
bcc b2
|
||||
beq b2
|
||||
//SEG9 @3
|
||||
//SEG10 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby
|
||||
stx $ff
|
||||
clc
|
||||
adc $ff
|
||||
//SEG17 [2] phi from @2 to @3
|
||||
//SEG18 [2] phi (byte) s#4 = (byte) s#1 -- register_copy
|
||||
jmp b3
|
||||
//SEG11 [3] phi from @3 to @2
|
||||
//SEG12 [3] phi (byte) s#4 = (byte) s#1 -- register_copy
|
||||
//SEG13 [3] phi from @1 to @2
|
||||
//SEG14 [3] phi (byte) s#4 = (byte) s#2 -- register_copy
|
||||
//SEG15 @2
|
||||
b2:
|
||||
//SEG16 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby
|
||||
dex
|
||||
//SEG17 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1
|
||||
cpx #$0
|
||||
bne b1
|
||||
//SEG18 @end
|
||||
|
||||
FINAL SYMBOL TABLE
|
||||
(label) @1
|
||||
@ -637,33 +661,30 @@ FINAL CODE
|
||||
lda #$0
|
||||
//SEG3 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1
|
||||
ldx #$a
|
||||
//SEG4 [0] phi from @3 to @1
|
||||
//SEG4 [0] phi from @2 to @1
|
||||
//SEG5 [0] phi (byte) s#2 = (byte) s#4 -- register_copy
|
||||
//SEG6 [0] phi (byte) i#2 = (byte) i#1 -- register_copy
|
||||
//SEG7 @1
|
||||
b1:
|
||||
//SEG8 [1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ] -- xby_gt_coby1_then_la1
|
||||
//SEG8 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1
|
||||
cpx #$5
|
||||
beq !+
|
||||
bcs b2
|
||||
!:
|
||||
//SEG9 [2] phi from @1 to @3
|
||||
//SEG10 [2] phi (byte) s#4 = (byte) s#2 -- register_copy
|
||||
//SEG11 @3
|
||||
b3:
|
||||
//SEG12 [3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby
|
||||
dex
|
||||
//SEG13 [4] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1
|
||||
cpx #$0
|
||||
bne b1
|
||||
//SEG14 @end
|
||||
//SEG15 @2
|
||||
b2:
|
||||
//SEG16 [5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby
|
||||
bcc b2
|
||||
beq b2
|
||||
//SEG9 @3
|
||||
//SEG10 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby
|
||||
stx $ff
|
||||
clc
|
||||
adc $ff
|
||||
//SEG17 [2] phi from @2 to @3
|
||||
//SEG18 [2] phi (byte) s#4 = (byte) s#1 -- register_copy
|
||||
jmp b3
|
||||
//SEG11 [3] phi from @3 to @2
|
||||
//SEG12 [3] phi (byte) s#4 = (byte) s#1 -- register_copy
|
||||
//SEG13 [3] phi from @1 to @2
|
||||
//SEG14 [3] phi (byte) s#4 = (byte) s#2 -- register_copy
|
||||
//SEG15 @2
|
||||
b2:
|
||||
//SEG16 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby
|
||||
dex
|
||||
//SEG17 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1
|
||||
cpx #$0
|
||||
bne b1
|
||||
//SEG18 @end
|
||||
|
||||
|
||||
@ -9,12 +9,11 @@ main: {
|
||||
rts
|
||||
b2:
|
||||
cpx #$32
|
||||
beq !+
|
||||
bcs b4
|
||||
!:
|
||||
dey
|
||||
jmp b1
|
||||
b4:
|
||||
bcc b4
|
||||
beq b4
|
||||
iny
|
||||
jmp b1
|
||||
b4:
|
||||
dey
|
||||
jmp b1
|
||||
}
|
||||
|
||||
@ -4,9 +4,9 @@
|
||||
@end: scope:[] from @begin
|
||||
main: scope:[main] from @begin
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@4 main::@5
|
||||
[1] (byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@5/(byte) main::s#2 ) [ main::i#2 main::s#3 ]
|
||||
[1] (byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#1 main::@5/(byte) main::i#1 ) [ main::i#2 main::s#3 ]
|
||||
main::@1: scope:[main] from main main::@4 main::@8
|
||||
[1] (byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@8/(byte) main::s#2 ) [ main::i#2 main::s#3 ]
|
||||
[1] (byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#1 main::@8/(byte) main::i#1 ) [ main::i#2 main::s#3 ]
|
||||
[2] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 main::s#3 ]
|
||||
[3] if((byte) main::i#1>(byte) 0) goto main::@2 [ main::i#1 main::s#3 ]
|
||||
to:main::@return
|
||||
@ -14,11 +14,11 @@ main::@return: scope:[main] from main::@1
|
||||
[4] return [ ]
|
||||
to:@return
|
||||
main::@2: scope:[main] from main::@1
|
||||
[5] if((byte) main::i#1>(byte) 50) goto main::@4 [ main::i#1 main::s#3 ]
|
||||
to:main::@5
|
||||
main::@5: scope:[main] from main::@2
|
||||
[6] (byte) main::s#2 ← -- (byte) main::s#3 [ main::i#1 main::s#2 ]
|
||||
[5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ]
|
||||
to:main::@8
|
||||
main::@8: scope:[main] from main::@2
|
||||
[6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ]
|
||||
to:main::@1
|
||||
main::@4: scope:[main] from main::@2
|
||||
[7] (byte) main::s#1 ← ++ (byte) main::s#3 [ main::i#1 main::s#1 ]
|
||||
[7] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ]
|
||||
to:main::@1
|
||||
|
||||
@ -27,14 +27,13 @@ main::@1:
|
||||
goto main::@3
|
||||
main::@2:
|
||||
(boolean~) main::$1 ← (byte) main::i > (byte) 50
|
||||
if((boolean~) main::$1) goto main::@4
|
||||
(boolean~) main::$2 ← ! (boolean~) main::$1
|
||||
if((boolean~) main::$2) goto main::@4
|
||||
(byte) main::s ← ++ (byte) main::s
|
||||
goto main::@5
|
||||
main::@4:
|
||||
(byte) main::s ← ++ (byte) main::s
|
||||
goto main::@6
|
||||
main::@5:
|
||||
(byte) main::s ← -- (byte) main::s
|
||||
main::@6:
|
||||
main::@5:
|
||||
goto main::@1
|
||||
main::@3:
|
||||
main::@return:
|
||||
@ -46,12 +45,12 @@ SYMBOLS
|
||||
(void()) main()
|
||||
(boolean~) main::$0
|
||||
(boolean~) main::$1
|
||||
(boolean~) main::$2
|
||||
(label) main::@1
|
||||
(label) main::@2
|
||||
(label) main::@3
|
||||
(label) main::@4
|
||||
(label) main::@5
|
||||
(label) main::@6
|
||||
(label) main::@return
|
||||
(byte) main::i
|
||||
(byte) main::s
|
||||
@ -64,36 +63,33 @@ main: scope:[main] from
|
||||
(byte) main::i ← (byte) 100
|
||||
(byte) main::s ← (byte) 0
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@6
|
||||
main::@1: scope:[main] from main main::@5
|
||||
(byte) main::i ← -- (byte) main::i
|
||||
(boolean~) main::$0 ← (byte) main::i > (byte) 0
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
to:main::@7
|
||||
main::@2: scope:[main] from main::@1 main::@8
|
||||
to:main::@6
|
||||
main::@2: scope:[main] from main::@1 main::@7
|
||||
(boolean~) main::$1 ← (byte) main::i > (byte) 50
|
||||
if((boolean~) main::$1) goto main::@4
|
||||
to:main::@9
|
||||
main::@7: scope:[main] from main::@1
|
||||
(boolean~) main::$2 ← ! (boolean~) main::$1
|
||||
if((boolean~) main::$2) goto main::@4
|
||||
to:main::@8
|
||||
main::@6: scope:[main] from main::@1
|
||||
to:main::@3
|
||||
main::@3: scope:[main] from main::@12 main::@7
|
||||
main::@3: scope:[main] from main::@10 main::@6
|
||||
to:main::@return
|
||||
main::@8: scope:[main] from
|
||||
main::@7: scope:[main] from
|
||||
to:main::@2
|
||||
main::@4: scope:[main] from main::@10 main::@2
|
||||
(byte) main::s ← ++ (byte) main::s
|
||||
to:main::@6
|
||||
main::@9: scope:[main] from main::@2
|
||||
to:main::@5
|
||||
main::@5: scope:[main] from main::@11 main::@9
|
||||
main::@4: scope:[main] from main::@2 main::@9
|
||||
(byte) main::s ← -- (byte) main::s
|
||||
to:main::@6
|
||||
main::@10: scope:[main] from
|
||||
to:main::@4
|
||||
main::@6: scope:[main] from main::@4 main::@5
|
||||
to:main::@1
|
||||
main::@11: scope:[main] from
|
||||
to:main::@5
|
||||
main::@12: scope:[main] from
|
||||
main::@8: scope:[main] from main::@2
|
||||
(byte) main::s ← ++ (byte) main::s
|
||||
to:main::@5
|
||||
main::@5: scope:[main] from main::@4 main::@8
|
||||
to:main::@1
|
||||
main::@9: scope:[main] from
|
||||
to:main::@4
|
||||
main::@10: scope:[main] from
|
||||
to:main::@3
|
||||
main::@return: scope:[main] from main::@3
|
||||
return
|
||||
@ -102,14 +98,12 @@ main::@return: scope:[main] from main::@3
|
||||
to:@end
|
||||
@end: scope:[] from @1
|
||||
|
||||
Removing empty block main::@7
|
||||
Removing empty block main::@6
|
||||
Removing empty block main::@3
|
||||
Removing empty block main::@8
|
||||
Removing empty block main::@7
|
||||
Removing empty block main::@5
|
||||
Removing empty block main::@9
|
||||
Removing empty block main::@10
|
||||
Removing empty block main::@6
|
||||
Removing empty block main::@11
|
||||
Removing empty block main::@12
|
||||
Removing empty block @1
|
||||
CONTROL FLOW GRAPH
|
||||
@begin: scope:[] from
|
||||
@ -119,21 +113,22 @@ main: scope:[main] from
|
||||
(byte) main::i ← (byte) 100
|
||||
(byte) main::s ← (byte) 0
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@4 main::@5
|
||||
main::@1: scope:[main] from main main::@4 main::@8
|
||||
(byte) main::i ← -- (byte) main::i
|
||||
(boolean~) main::$0 ← (byte) main::i > (byte) 0
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
to:main::@return
|
||||
main::@2: scope:[main] from main::@1
|
||||
(boolean~) main::$1 ← (byte) main::i > (byte) 50
|
||||
if((boolean~) main::$1) goto main::@4
|
||||
to:main::@5
|
||||
(boolean~) main::$2 ← ! (boolean~) main::$1
|
||||
if((boolean~) main::$2) goto main::@4
|
||||
to:main::@8
|
||||
main::@4: scope:[main] from main::@2
|
||||
(byte) main::s ← ++ (byte) main::s
|
||||
to:main::@1
|
||||
main::@5: scope:[main] from main::@2
|
||||
(byte) main::s ← -- (byte) main::s
|
||||
to:main::@1
|
||||
main::@8: scope:[main] from main::@2
|
||||
(byte) main::s ← ++ (byte) main::s
|
||||
to:main::@1
|
||||
main::@return: scope:[main] from main::@1
|
||||
return
|
||||
to:@return
|
||||
@ -151,21 +146,22 @@ main: scope:[main] from @begin
|
||||
(byte) main::i ← (byte) 100
|
||||
(byte) main::s ← (byte) 0
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@4 main::@5
|
||||
main::@1: scope:[main] from main main::@4 main::@8
|
||||
(byte) main::i ← -- (byte) main::i
|
||||
(boolean~) main::$0 ← (byte) main::i > (byte) 0
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
to:main::@return
|
||||
main::@2: scope:[main] from main::@1
|
||||
(boolean~) main::$1 ← (byte) main::i > (byte) 50
|
||||
if((boolean~) main::$1) goto main::@4
|
||||
to:main::@5
|
||||
(boolean~) main::$2 ← ! (boolean~) main::$1
|
||||
if((boolean~) main::$2) goto main::@4
|
||||
to:main::@8
|
||||
main::@4: scope:[main] from main::@2
|
||||
(byte) main::s ← ++ (byte) main::s
|
||||
to:main::@1
|
||||
main::@5: scope:[main] from main::@2
|
||||
(byte) main::s ← -- (byte) main::s
|
||||
to:main::@1
|
||||
main::@8: scope:[main] from main::@2
|
||||
(byte) main::s ← ++ (byte) main::s
|
||||
to:main::@1
|
||||
main::@return: scope:[main] from main::@1
|
||||
return
|
||||
to:@return
|
||||
@ -184,9 +180,9 @@ main: scope:[main] from @begin
|
||||
(byte) main::i#0 ← (byte) 100
|
||||
(byte) main::s#0 ← (byte) 0
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@4 main::@5
|
||||
(byte) main::s#6 ← phi( main/(byte) main::s#0 main::@4/(byte) main::s#1 main::@5/(byte) main::s#2 )
|
||||
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@4/(byte) main::i#4 main::@5/(byte) main::i#5 )
|
||||
main::@1: scope:[main] from main main::@4 main::@8
|
||||
(byte) main::s#6 ← phi( main/(byte) main::s#0 main::@4/(byte) main::s#1 main::@8/(byte) main::s#2 )
|
||||
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@4/(byte) main::i#4 main::@8/(byte) main::i#5 )
|
||||
(byte) main::i#1 ← -- (byte) main::i#2
|
||||
(boolean~) main::$0 ← (byte) main::i#1 > (byte) 0
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
@ -195,17 +191,18 @@ main::@2: scope:[main] from main::@1
|
||||
(byte) main::s#5 ← phi( main::@1/(byte) main::s#6 )
|
||||
(byte) main::i#3 ← phi( main::@1/(byte) main::i#1 )
|
||||
(boolean~) main::$1 ← (byte) main::i#3 > (byte) 50
|
||||
if((boolean~) main::$1) goto main::@4
|
||||
to:main::@5
|
||||
(boolean~) main::$2 ← ! (boolean~) main::$1
|
||||
if((boolean~) main::$2) goto main::@4
|
||||
to:main::@8
|
||||
main::@4: scope:[main] from main::@2
|
||||
(byte) main::i#4 ← phi( main::@2/(byte) main::i#3 )
|
||||
(byte) main::s#3 ← phi( main::@2/(byte) main::s#5 )
|
||||
(byte) main::s#1 ← ++ (byte) main::s#3
|
||||
(byte) main::s#1 ← -- (byte) main::s#3
|
||||
to:main::@1
|
||||
main::@5: scope:[main] from main::@2
|
||||
main::@8: scope:[main] from main::@2
|
||||
(byte) main::i#5 ← phi( main::@2/(byte) main::i#3 )
|
||||
(byte) main::s#4 ← phi( main::@2/(byte) main::s#5 )
|
||||
(byte) main::s#2 ← -- (byte) main::s#4
|
||||
(byte) main::s#2 ← ++ (byte) main::s#4
|
||||
to:main::@1
|
||||
main::@return: scope:[main] from main::@1
|
||||
return
|
||||
@ -222,9 +219,9 @@ main: scope:[main] from @begin
|
||||
(byte) main::i#0 ← (byte) 100
|
||||
(byte) main::s#0 ← (byte) 0
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@4 main::@5
|
||||
(byte) main::s#6 ← phi( main/(byte) main::s#0 main::@4/(byte) main::s#1 main::@5/(byte) main::s#2 )
|
||||
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@4/(byte) main::i#4 main::@5/(byte) main::i#5 )
|
||||
main::@1: scope:[main] from main main::@4 main::@8
|
||||
(byte) main::s#6 ← phi( main/(byte) main::s#0 main::@4/(byte) main::s#1 main::@8/(byte) main::s#2 )
|
||||
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@4/(byte) main::i#4 main::@8/(byte) main::i#5 )
|
||||
(byte) main::i#1 ← -- (byte) main::i#2
|
||||
(boolean~) main::$0 ← (byte) main::i#1 > (byte) 0
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
@ -233,17 +230,18 @@ main::@2: scope:[main] from main::@1
|
||||
(byte) main::s#5 ← phi( main::@1/(byte) main::s#6 )
|
||||
(byte) main::i#3 ← phi( main::@1/(byte) main::i#1 )
|
||||
(boolean~) main::$1 ← (byte) main::i#3 > (byte) 50
|
||||
if((boolean~) main::$1) goto main::@4
|
||||
to:main::@5
|
||||
(boolean~) main::$2 ← ! (boolean~) main::$1
|
||||
if((boolean~) main::$2) goto main::@4
|
||||
to:main::@8
|
||||
main::@4: scope:[main] from main::@2
|
||||
(byte) main::i#4 ← phi( main::@2/(byte) main::i#3 )
|
||||
(byte) main::s#3 ← phi( main::@2/(byte) main::s#5 )
|
||||
(byte) main::s#1 ← ++ (byte) main::s#3
|
||||
(byte) main::s#1 ← -- (byte) main::s#3
|
||||
to:main::@1
|
||||
main::@5: scope:[main] from main::@2
|
||||
main::@8: scope:[main] from main::@2
|
||||
(byte) main::i#5 ← phi( main::@2/(byte) main::i#3 )
|
||||
(byte) main::s#4 ← phi( main::@2/(byte) main::s#5 )
|
||||
(byte) main::s#2 ← -- (byte) main::s#4
|
||||
(byte) main::s#2 ← ++ (byte) main::s#4
|
||||
to:main::@1
|
||||
main::@return: scope:[main] from main::@1
|
||||
return
|
||||
@ -260,9 +258,9 @@ main: scope:[main] from @begin
|
||||
(byte) main::i#0 ← (byte) 100
|
||||
(byte) main::s#0 ← (byte) 0
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@4 main::@5
|
||||
(byte) main::s#6 ← phi( main/(byte) main::s#0 main::@4/(byte) main::s#1 main::@5/(byte) main::s#2 )
|
||||
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@4/(byte) main::i#4 main::@5/(byte) main::i#5 )
|
||||
main::@1: scope:[main] from main main::@4 main::@8
|
||||
(byte) main::s#6 ← phi( main/(byte) main::s#0 main::@4/(byte) main::s#1 main::@8/(byte) main::s#2 )
|
||||
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@4/(byte) main::i#4 main::@8/(byte) main::i#5 )
|
||||
(byte) main::i#1 ← -- (byte) main::i#2
|
||||
(boolean~) main::$0 ← (byte) main::i#1 > (byte) 0
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
@ -271,17 +269,18 @@ main::@2: scope:[main] from main::@1
|
||||
(byte) main::s#5 ← phi( main::@1/(byte) main::s#6 )
|
||||
(byte) main::i#3 ← phi( main::@1/(byte) main::i#1 )
|
||||
(boolean~) main::$1 ← (byte) main::i#3 > (byte) 50
|
||||
if((boolean~) main::$1) goto main::@4
|
||||
to:main::@5
|
||||
(boolean~) main::$2 ← ! (boolean~) main::$1
|
||||
if((boolean~) main::$2) goto main::@4
|
||||
to:main::@8
|
||||
main::@4: scope:[main] from main::@2
|
||||
(byte) main::i#4 ← phi( main::@2/(byte) main::i#3 )
|
||||
(byte) main::s#3 ← phi( main::@2/(byte) main::s#5 )
|
||||
(byte) main::s#1 ← ++ (byte) main::s#3
|
||||
(byte) main::s#1 ← -- (byte) main::s#3
|
||||
to:main::@1
|
||||
main::@5: scope:[main] from main::@2
|
||||
main::@8: scope:[main] from main::@2
|
||||
(byte) main::i#5 ← phi( main::@2/(byte) main::i#3 )
|
||||
(byte) main::s#4 ← phi( main::@2/(byte) main::s#5 )
|
||||
(byte) main::s#2 ← -- (byte) main::s#4
|
||||
(byte) main::s#2 ← ++ (byte) main::s#4
|
||||
to:main::@1
|
||||
main::@return: scope:[main] from main::@1
|
||||
return
|
||||
@ -297,9 +296,9 @@ CONTROL FLOW GRAPH
|
||||
to:@end
|
||||
main: scope:[main] from @begin
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@4 main::@5
|
||||
(byte) main::s#6 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@5/(byte) main::s#2 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#4 main::@5/(byte) main::i#5 )
|
||||
main::@1: scope:[main] from main main::@4 main::@8
|
||||
(byte) main::s#6 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@8/(byte) main::s#2 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#4 main::@8/(byte) main::i#5 )
|
||||
(byte) main::i#1 ← -- (byte) main::i#2
|
||||
(boolean~) main::$0 ← (byte) main::i#1 > (byte) 0
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
@ -308,17 +307,54 @@ main::@2: scope:[main] from main::@1
|
||||
(byte) main::s#5 ← phi( main::@1/(byte) main::s#6 )
|
||||
(byte) main::i#3 ← phi( main::@1/(byte) main::i#1 )
|
||||
(boolean~) main::$1 ← (byte) main::i#3 > (byte) 50
|
||||
if((boolean~) main::$1) goto main::@4
|
||||
to:main::@5
|
||||
(boolean~) main::$2 ← ! (boolean~) main::$1
|
||||
if((boolean~) main::$2) goto main::@4
|
||||
to:main::@8
|
||||
main::@4: scope:[main] from main::@2
|
||||
(byte) main::i#4 ← phi( main::@2/(byte) main::i#3 )
|
||||
(byte) main::s#3 ← phi( main::@2/(byte) main::s#5 )
|
||||
(byte) main::s#1 ← ++ (byte) main::s#3
|
||||
(byte) main::s#1 ← -- (byte) main::s#3
|
||||
to:main::@1
|
||||
main::@5: scope:[main] from main::@2
|
||||
main::@8: scope:[main] from main::@2
|
||||
(byte) main::i#5 ← phi( main::@2/(byte) main::i#3 )
|
||||
(byte) main::s#4 ← phi( main::@2/(byte) main::s#5 )
|
||||
(byte) main::s#2 ← -- (byte) main::s#4
|
||||
(byte) main::s#2 ← ++ (byte) main::s#4
|
||||
to:main::@1
|
||||
main::@return: scope:[main] from main::@1
|
||||
return
|
||||
to:@return
|
||||
@end: scope:[] from @begin
|
||||
|
||||
Inversing boolean not (boolean~) main::$2 ← (byte) main::i#3 <= (byte) 50 from (boolean~) main::$1 ← (byte) main::i#3 > (byte) 50
|
||||
Succesful SSA optimization Pass2UnaryNotSimplification
|
||||
CONTROL FLOW GRAPH
|
||||
@begin: scope:[] from
|
||||
call main param-assignment
|
||||
to:@end
|
||||
main: scope:[main] from @begin
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@4 main::@8
|
||||
(byte) main::s#6 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@8/(byte) main::s#2 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#4 main::@8/(byte) main::i#5 )
|
||||
(byte) main::i#1 ← -- (byte) main::i#2
|
||||
(boolean~) main::$0 ← (byte) main::i#1 > (byte) 0
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
to:main::@return
|
||||
main::@2: scope:[main] from main::@1
|
||||
(byte) main::s#5 ← phi( main::@1/(byte) main::s#6 )
|
||||
(byte) main::i#3 ← phi( main::@1/(byte) main::i#1 )
|
||||
(boolean~) main::$2 ← (byte) main::i#3 <= (byte) 50
|
||||
if((boolean~) main::$2) goto main::@4
|
||||
to:main::@8
|
||||
main::@4: scope:[main] from main::@2
|
||||
(byte) main::i#4 ← phi( main::@2/(byte) main::i#3 )
|
||||
(byte) main::s#3 ← phi( main::@2/(byte) main::s#5 )
|
||||
(byte) main::s#1 ← -- (byte) main::s#3
|
||||
to:main::@1
|
||||
main::@8: scope:[main] from main::@2
|
||||
(byte) main::i#5 ← phi( main::@2/(byte) main::i#3 )
|
||||
(byte) main::s#4 ← phi( main::@2/(byte) main::s#5 )
|
||||
(byte) main::s#2 ← ++ (byte) main::s#4
|
||||
to:main::@1
|
||||
main::@return: scope:[main] from main::@1
|
||||
return
|
||||
@ -334,22 +370,22 @@ CONTROL FLOW GRAPH
|
||||
to:@end
|
||||
main: scope:[main] from @begin
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@4 main::@5
|
||||
(byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@5/(byte) main::s#2 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#1 main::@5/(byte) main::i#1 )
|
||||
main::@1: scope:[main] from main main::@4 main::@8
|
||||
(byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@8/(byte) main::s#2 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#1 main::@8/(byte) main::i#1 )
|
||||
(byte) main::i#1 ← -- (byte) main::i#2
|
||||
(boolean~) main::$0 ← (byte) main::i#1 > (byte) 0
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
to:main::@return
|
||||
main::@2: scope:[main] from main::@1
|
||||
(boolean~) main::$1 ← (byte) main::i#1 > (byte) 50
|
||||
if((boolean~) main::$1) goto main::@4
|
||||
to:main::@5
|
||||
(boolean~) main::$2 ← (byte) main::i#1 <= (byte) 50
|
||||
if((boolean~) main::$2) goto main::@4
|
||||
to:main::@8
|
||||
main::@4: scope:[main] from main::@2
|
||||
(byte) main::s#1 ← ++ (byte) main::s#3
|
||||
(byte) main::s#1 ← -- (byte) main::s#3
|
||||
to:main::@1
|
||||
main::@5: scope:[main] from main::@2
|
||||
(byte) main::s#2 ← -- (byte) main::s#3
|
||||
main::@8: scope:[main] from main::@2
|
||||
(byte) main::s#2 ← ++ (byte) main::s#3
|
||||
to:main::@1
|
||||
main::@return: scope:[main] from main::@1
|
||||
return
|
||||
@ -357,7 +393,7 @@ main::@return: scope:[main] from main::@1
|
||||
@end: scope:[] from @begin
|
||||
|
||||
Simple Condition (boolean~) main::$0 if((byte) main::i#1>(byte) 0) goto main::@2
|
||||
Simple Condition (boolean~) main::$1 if((byte) main::i#1>(byte) 50) goto main::@4
|
||||
Simple Condition (boolean~) main::$2 if((byte) main::i#1<=(byte) 50) goto main::@4
|
||||
Succesful SSA optimization Pass2ConditionalJumpSimplification
|
||||
CONTROL FLOW GRAPH
|
||||
@begin: scope:[] from
|
||||
@ -365,28 +401,28 @@ CONTROL FLOW GRAPH
|
||||
to:@end
|
||||
main: scope:[main] from @begin
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@4 main::@5
|
||||
(byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@5/(byte) main::s#2 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#1 main::@5/(byte) main::i#1 )
|
||||
main::@1: scope:[main] from main main::@4 main::@8
|
||||
(byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@8/(byte) main::s#2 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#1 main::@8/(byte) main::i#1 )
|
||||
(byte) main::i#1 ← -- (byte) main::i#2
|
||||
if((byte) main::i#1>(byte) 0) goto main::@2
|
||||
to:main::@return
|
||||
main::@2: scope:[main] from main::@1
|
||||
if((byte) main::i#1>(byte) 50) goto main::@4
|
||||
to:main::@5
|
||||
if((byte) main::i#1<=(byte) 50) goto main::@4
|
||||
to:main::@8
|
||||
main::@4: scope:[main] from main::@2
|
||||
(byte) main::s#1 ← ++ (byte) main::s#3
|
||||
(byte) main::s#1 ← -- (byte) main::s#3
|
||||
to:main::@1
|
||||
main::@5: scope:[main] from main::@2
|
||||
(byte) main::s#2 ← -- (byte) main::s#3
|
||||
main::@8: scope:[main] from main::@2
|
||||
(byte) main::s#2 ← ++ (byte) main::s#3
|
||||
to:main::@1
|
||||
main::@return: scope:[main] from main::@1
|
||||
return
|
||||
to:@return
|
||||
@end: scope:[] from @begin
|
||||
|
||||
Block Sequence Planned @begin @end main main::@1 main::@return main::@2 main::@5 main::@4
|
||||
Block Sequence Planned @begin @end main main::@1 main::@return main::@2 main::@5 main::@4
|
||||
Block Sequence Planned @begin @end main main::@1 main::@return main::@2 main::@8 main::@4
|
||||
Block Sequence Planned @begin @end main main::@1 main::@return main::@2 main::@8 main::@4
|
||||
CONTROL FLOW GRAPH - PHI LIFTED
|
||||
@begin: scope:[] from
|
||||
call main param-assignment
|
||||
@ -394,9 +430,9 @@ CONTROL FLOW GRAPH - PHI LIFTED
|
||||
@end: scope:[] from @begin
|
||||
main: scope:[main] from @begin
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@4 main::@5
|
||||
(byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte~) main::s#7 main::@5/(byte~) main::s#8 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte~) main::i#6 main::@5/(byte~) main::i#7 )
|
||||
main::@1: scope:[main] from main main::@4 main::@8
|
||||
(byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte~) main::s#7 main::@8/(byte~) main::s#8 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte~) main::i#6 main::@8/(byte~) main::i#7 )
|
||||
(byte) main::i#1 ← -- (byte) main::i#2
|
||||
if((byte) main::i#1>(byte) 0) goto main::@2
|
||||
to:main::@return
|
||||
@ -404,15 +440,15 @@ main::@return: scope:[main] from main::@1
|
||||
return
|
||||
to:@return
|
||||
main::@2: scope:[main] from main::@1
|
||||
if((byte) main::i#1>(byte) 50) goto main::@4
|
||||
to:main::@5
|
||||
main::@5: scope:[main] from main::@2
|
||||
(byte) main::s#2 ← -- (byte) main::s#3
|
||||
if((byte) main::i#1<=(byte) 50) goto main::@4
|
||||
to:main::@8
|
||||
main::@8: scope:[main] from main::@2
|
||||
(byte) main::s#2 ← ++ (byte) main::s#3
|
||||
(byte~) main::i#7 ← (byte) main::i#1
|
||||
(byte~) main::s#8 ← (byte) main::s#2
|
||||
to:main::@1
|
||||
main::@4: scope:[main] from main::@2
|
||||
(byte) main::s#1 ← ++ (byte) main::s#3
|
||||
(byte) main::s#1 ← -- (byte) main::s#3
|
||||
(byte~) main::i#6 ← (byte) main::i#1
|
||||
(byte~) main::s#7 ← (byte) main::s#1
|
||||
to:main::@1
|
||||
@ -428,9 +464,9 @@ CONTROL FLOW GRAPH - LIVE RANGES
|
||||
@end: scope:[] from @begin
|
||||
main: scope:[main] from @begin
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@4 main::@5
|
||||
[1] (byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte~) main::s#7 main::@5/(byte~) main::s#8 ) [ main::i#2 main::s#3 ]
|
||||
[1] (byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte~) main::i#6 main::@5/(byte~) main::i#7 ) [ main::i#2 main::s#3 ]
|
||||
main::@1: scope:[main] from main main::@4 main::@8
|
||||
[1] (byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte~) main::s#7 main::@8/(byte~) main::s#8 ) [ main::i#2 main::s#3 ]
|
||||
[1] (byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte~) main::i#6 main::@8/(byte~) main::i#7 ) [ main::i#2 main::s#3 ]
|
||||
[2] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 main::s#3 ]
|
||||
[3] if((byte) main::i#1>(byte) 0) goto main::@2 [ main::i#1 main::s#3 ]
|
||||
to:main::@return
|
||||
@ -438,15 +474,15 @@ main::@return: scope:[main] from main::@1
|
||||
[4] return [ ]
|
||||
to:@return
|
||||
main::@2: scope:[main] from main::@1
|
||||
[5] if((byte) main::i#1>(byte) 50) goto main::@4 [ main::i#1 main::s#3 ]
|
||||
to:main::@5
|
||||
main::@5: scope:[main] from main::@2
|
||||
[6] (byte) main::s#2 ← -- (byte) main::s#3 [ main::i#1 main::s#2 ]
|
||||
[5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ]
|
||||
to:main::@8
|
||||
main::@8: scope:[main] from main::@2
|
||||
[6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ]
|
||||
[7] (byte~) main::i#7 ← (byte) main::i#1 [ main::i#7 main::s#2 ]
|
||||
[8] (byte~) main::s#8 ← (byte) main::s#2 [ main::i#7 main::s#8 ]
|
||||
to:main::@1
|
||||
main::@4: scope:[main] from main::@2
|
||||
[9] (byte) main::s#1 ← ++ (byte) main::s#3 [ main::i#1 main::s#1 ]
|
||||
[9] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ]
|
||||
[10] (byte~) main::i#6 ← (byte) main::i#1 [ main::i#6 main::s#1 ]
|
||||
[11] (byte~) main::s#7 ← (byte) main::s#1 [ main::i#6 main::s#7 ]
|
||||
to:main::@1
|
||||
@ -457,7 +493,7 @@ Coalesced [8] main::s#8 ← main::s#2
|
||||
Coalesced (already) [10] main::i#6 ← main::i#1
|
||||
Coalesced [11] main::s#7 ← main::s#1
|
||||
Coalesced down to 2 phi equivalence classes
|
||||
Block Sequence Planned @begin @end main main::@1 main::@return main::@2 main::@5 main::@4
|
||||
Block Sequence Planned @begin @end main main::@1 main::@return main::@2 main::@8 main::@4
|
||||
Propagating live ranges...
|
||||
Propagating live ranges...
|
||||
Propagating live ranges...
|
||||
@ -469,9 +505,9 @@ CONTROL FLOW GRAPH - PHI MEM COALESCED
|
||||
@end: scope:[] from @begin
|
||||
main: scope:[main] from @begin
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@4 main::@5
|
||||
[1] (byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@5/(byte) main::s#2 ) [ main::i#2 main::s#3 ]
|
||||
[1] (byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#1 main::@5/(byte) main::i#1 ) [ main::i#2 main::s#3 ]
|
||||
main::@1: scope:[main] from main main::@4 main::@8
|
||||
[1] (byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@8/(byte) main::s#2 ) [ main::i#2 main::s#3 ]
|
||||
[1] (byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#1 main::@8/(byte) main::i#1 ) [ main::i#2 main::s#3 ]
|
||||
[2] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 main::s#3 ]
|
||||
[3] if((byte) main::i#1>(byte) 0) goto main::@2 [ main::i#1 main::s#3 ]
|
||||
to:main::@return
|
||||
@ -479,13 +515,13 @@ main::@return: scope:[main] from main::@1
|
||||
[4] return [ ]
|
||||
to:@return
|
||||
main::@2: scope:[main] from main::@1
|
||||
[5] if((byte) main::i#1>(byte) 50) goto main::@4 [ main::i#1 main::s#3 ]
|
||||
to:main::@5
|
||||
main::@5: scope:[main] from main::@2
|
||||
[6] (byte) main::s#2 ← -- (byte) main::s#3 [ main::i#1 main::s#2 ]
|
||||
[5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ]
|
||||
to:main::@8
|
||||
main::@8: scope:[main] from main::@2
|
||||
[6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ]
|
||||
to:main::@1
|
||||
main::@4: scope:[main] from main::@2
|
||||
[7] (byte) main::s#1 ← ++ (byte) main::s#3 [ main::i#1 main::s#1 ]
|
||||
[7] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ]
|
||||
to:main::@1
|
||||
|
||||
CALL GRAPH
|
||||
@ -498,22 +534,22 @@ main dominated by @begin main
|
||||
main::@1 dominated by @begin main::@1 main
|
||||
main::@return dominated by main::@return @begin main::@1 main
|
||||
main::@2 dominated by @begin main::@2 main::@1 main
|
||||
main::@5 dominated by @begin main::@2 main::@1 main::@5 main
|
||||
main::@8 dominated by main::@8 @begin main::@2 main::@1 main
|
||||
main::@4 dominated by @begin main::@2 main::@1 main::@4 main
|
||||
|
||||
Found back edge: Loop head: main::@1 tails: main::@5 blocks: null
|
||||
Found back edge: Loop head: main::@1 tails: main::@8 blocks: null
|
||||
Found back edge: Loop head: main::@1 tails: main::@4 blocks: null
|
||||
Populated: Loop head: main::@1 tails: main::@5 blocks: main::@5 main::@2 main::@1
|
||||
Populated: Loop head: main::@1 tails: main::@8 blocks: main::@8 main::@2 main::@1
|
||||
Populated: Loop head: main::@1 tails: main::@4 blocks: main::@4 main::@2 main::@1
|
||||
Coalesced: Loop head: main::@1 tails: main::@5 main::@4 blocks: main::@5 main::@2 main::@1 main::@4
|
||||
Coalesced: Loop head: main::@1 tails: main::@8 main::@4 blocks: main::@8 main::@2 main::@1 main::@4
|
||||
NATURAL LOOPS
|
||||
Loop head: main::@1 tails: main::@5 main::@4 blocks: main::@5 main::@2 main::@1 main::@4
|
||||
Loop head: main::@1 tails: main::@8 main::@4 blocks: main::@8 main::@2 main::@1 main::@4
|
||||
|
||||
Found 0 loops in scope []
|
||||
Found 1 loops in scope [main]
|
||||
Loop head: main::@1 tails: main::@5 main::@4 blocks: main::@5 main::@2 main::@1 main::@4
|
||||
Loop head: main::@1 tails: main::@8 main::@4 blocks: main::@8 main::@2 main::@1 main::@4
|
||||
NATURAL LOOPS WITH DEPTH
|
||||
Loop head: main::@1 tails: main::@5 main::@4 blocks: main::@5 main::@2 main::@1 main::@4 depth: 1
|
||||
Loop head: main::@1 tails: main::@8 main::@4 blocks: main::@8 main::@2 main::@1 main::@4 depth: 1
|
||||
|
||||
|
||||
VARIABLE REGISTER WEIGHTS
|
||||
@ -567,26 +603,25 @@ main: {
|
||||
rts
|
||||
//SEG12 main::@2
|
||||
b2:
|
||||
//SEG13 [5] if((byte) main::i#1>(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- zpby1_gt_coby1_then_la1
|
||||
//SEG13 [5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- zpby1_le_coby1_then_la1
|
||||
lda $2
|
||||
cmp #$32
|
||||
beq !+
|
||||
bcs b4
|
||||
!:
|
||||
jmp b5
|
||||
//SEG14 main::@5
|
||||
b5:
|
||||
//SEG15 [6] (byte) main::s#2 ← -- (byte) main::s#3 [ main::i#1 main::s#2 ] -- zpby1=_dec_zpby1
|
||||
dec $3
|
||||
//SEG16 [1] phi from main::@5 to main::@1
|
||||
b1_from_b5:
|
||||
bcc b4
|
||||
beq b4
|
||||
jmp b8
|
||||
//SEG14 main::@8
|
||||
b8:
|
||||
//SEG15 [6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ] -- zpby1=_inc_zpby1
|
||||
inc $3
|
||||
//SEG16 [1] phi from main::@8 to main::@1
|
||||
b1_from_b8:
|
||||
//SEG17 [1] phi (byte) main::s#3 = (byte) main::s#2 -- register_copy
|
||||
//SEG18 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy
|
||||
jmp b1
|
||||
//SEG19 main::@4
|
||||
b4:
|
||||
//SEG20 [7] (byte) main::s#1 ← ++ (byte) main::s#3 [ main::i#1 main::s#1 ] -- zpby1=_inc_zpby1
|
||||
inc $3
|
||||
//SEG20 [7] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ] -- zpby1=_dec_zpby1
|
||||
dec $3
|
||||
//SEG21 [1] phi from main::@4 to main::@1
|
||||
b1_from_b4:
|
||||
//SEG22 [1] phi (byte) main::s#3 = (byte) main::s#1 -- register_copy
|
||||
@ -607,7 +642,7 @@ Uplifting [] best 380 combination
|
||||
Removing instruction jmp bend
|
||||
Removing instruction jmp b1
|
||||
Removing instruction jmp breturn
|
||||
Removing instruction jmp b5
|
||||
Removing instruction jmp b8
|
||||
Succesful ASM optimization Pass5NextJumpElimination
|
||||
ASSEMBLER
|
||||
//SEG0 @begin
|
||||
@ -637,24 +672,23 @@ main: {
|
||||
rts
|
||||
//SEG12 main::@2
|
||||
b2:
|
||||
//SEG13 [5] if((byte) main::i#1>(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- xby_gt_coby1_then_la1
|
||||
//SEG13 [5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- xby_le_coby1_then_la1
|
||||
cpx #$32
|
||||
beq !+
|
||||
bcs b4
|
||||
!:
|
||||
//SEG14 main::@5
|
||||
b5:
|
||||
//SEG15 [6] (byte) main::s#2 ← -- (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_dec_yby
|
||||
dey
|
||||
//SEG16 [1] phi from main::@5 to main::@1
|
||||
b1_from_b5:
|
||||
bcc b4
|
||||
beq b4
|
||||
//SEG14 main::@8
|
||||
b8:
|
||||
//SEG15 [6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_inc_yby
|
||||
iny
|
||||
//SEG16 [1] phi from main::@8 to main::@1
|
||||
b1_from_b8:
|
||||
//SEG17 [1] phi (byte) main::s#3 = (byte) main::s#2 -- register_copy
|
||||
//SEG18 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy
|
||||
jmp b1
|
||||
//SEG19 main::@4
|
||||
b4:
|
||||
//SEG20 [7] (byte) main::s#1 ← ++ (byte) main::s#3 [ main::i#1 main::s#1 ] -- yby=_inc_yby
|
||||
iny
|
||||
//SEG20 [7] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ] -- yby=_dec_yby
|
||||
dey
|
||||
//SEG21 [1] phi from main::@4 to main::@1
|
||||
b1_from_b4:
|
||||
//SEG22 [1] phi (byte) main::s#3 = (byte) main::s#1 -- register_copy
|
||||
@ -666,8 +700,8 @@ Removing instruction bbegin:
|
||||
Removing instruction bend:
|
||||
Removing instruction b1_from_main:
|
||||
Removing instruction breturn:
|
||||
Removing instruction b5:
|
||||
Removing instruction b1_from_b5:
|
||||
Removing instruction b8:
|
||||
Removing instruction b1_from_b8:
|
||||
Removing instruction b1_from_b4:
|
||||
Succesful ASM optimization Pass5UnusedLabelElimination
|
||||
ASSEMBLER
|
||||
@ -694,22 +728,21 @@ main: {
|
||||
rts
|
||||
//SEG12 main::@2
|
||||
b2:
|
||||
//SEG13 [5] if((byte) main::i#1>(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- xby_gt_coby1_then_la1
|
||||
//SEG13 [5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- xby_le_coby1_then_la1
|
||||
cpx #$32
|
||||
beq !+
|
||||
bcs b4
|
||||
!:
|
||||
//SEG14 main::@5
|
||||
//SEG15 [6] (byte) main::s#2 ← -- (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_dec_yby
|
||||
dey
|
||||
//SEG16 [1] phi from main::@5 to main::@1
|
||||
bcc b4
|
||||
beq b4
|
||||
//SEG14 main::@8
|
||||
//SEG15 [6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_inc_yby
|
||||
iny
|
||||
//SEG16 [1] phi from main::@8 to main::@1
|
||||
//SEG17 [1] phi (byte) main::s#3 = (byte) main::s#2 -- register_copy
|
||||
//SEG18 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy
|
||||
jmp b1
|
||||
//SEG19 main::@4
|
||||
b4:
|
||||
//SEG20 [7] (byte) main::s#1 ← ++ (byte) main::s#3 [ main::i#1 main::s#1 ] -- yby=_inc_yby
|
||||
iny
|
||||
//SEG20 [7] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ] -- yby=_dec_yby
|
||||
dey
|
||||
//SEG21 [1] phi from main::@4 to main::@1
|
||||
//SEG22 [1] phi (byte) main::s#3 = (byte) main::s#1 -- register_copy
|
||||
//SEG23 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy
|
||||
@ -723,7 +756,7 @@ FINAL SYMBOL TABLE
|
||||
(label) main::@1
|
||||
(label) main::@2
|
||||
(label) main::@4
|
||||
(label) main::@5
|
||||
(label) main::@8
|
||||
(label) main::@return
|
||||
(byte) main::i
|
||||
(byte) main::i#1 reg byte x 11.0
|
||||
@ -760,22 +793,21 @@ main: {
|
||||
rts
|
||||
//SEG12 main::@2
|
||||
b2:
|
||||
//SEG13 [5] if((byte) main::i#1>(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- xby_gt_coby1_then_la1
|
||||
//SEG13 [5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- xby_le_coby1_then_la1
|
||||
cpx #$32
|
||||
beq !+
|
||||
bcs b4
|
||||
!:
|
||||
//SEG14 main::@5
|
||||
//SEG15 [6] (byte) main::s#2 ← -- (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_dec_yby
|
||||
dey
|
||||
//SEG16 [1] phi from main::@5 to main::@1
|
||||
bcc b4
|
||||
beq b4
|
||||
//SEG14 main::@8
|
||||
//SEG15 [6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_inc_yby
|
||||
iny
|
||||
//SEG16 [1] phi from main::@8 to main::@1
|
||||
//SEG17 [1] phi (byte) main::s#3 = (byte) main::s#2 -- register_copy
|
||||
//SEG18 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy
|
||||
jmp b1
|
||||
//SEG19 main::@4
|
||||
b4:
|
||||
//SEG20 [7] (byte) main::s#1 ← ++ (byte) main::s#3 [ main::i#1 main::s#1 ] -- yby=_inc_yby
|
||||
iny
|
||||
//SEG20 [7] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ] -- yby=_dec_yby
|
||||
dey
|
||||
//SEG21 [1] phi from main::@4 to main::@1
|
||||
//SEG22 [1] phi (byte) main::s#3 = (byte) main::s#1 -- register_copy
|
||||
//SEG23 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
(label) main::@1
|
||||
(label) main::@2
|
||||
(label) main::@4
|
||||
(label) main::@5
|
||||
(label) main::@8
|
||||
(label) main::@return
|
||||
(byte) main::i
|
||||
(byte) main::i#1 reg byte x 11.0
|
||||
|
||||
@ -46,40 +46,45 @@ animate: {
|
||||
sta $1000
|
||||
lda $1000
|
||||
cmp #$28
|
||||
beq b1
|
||||
b2:
|
||||
bne b1
|
||||
lda #$0
|
||||
sta $1000
|
||||
b1:
|
||||
lda $1100
|
||||
clc
|
||||
adc #$1
|
||||
sta $1100
|
||||
lda $1100
|
||||
cmp #$19
|
||||
beq b3
|
||||
b4:
|
||||
bne b2
|
||||
lda #$0
|
||||
sta $1100
|
||||
b2:
|
||||
ldx $1001
|
||||
dex
|
||||
stx $1001
|
||||
lda $1001
|
||||
cmp #$ff
|
||||
beq b5
|
||||
b6:
|
||||
bne b3
|
||||
lda #$28
|
||||
sta $1001
|
||||
b3:
|
||||
lda $1102
|
||||
clc
|
||||
adc #$1
|
||||
sta $1102
|
||||
lda $1102
|
||||
cmp #$19
|
||||
beq b7
|
||||
b8:
|
||||
bne b4
|
||||
lda #$0
|
||||
sta $1102
|
||||
b4:
|
||||
ldx $1103
|
||||
dex
|
||||
stx $1103
|
||||
lda $1103
|
||||
cmp #$ff
|
||||
beq b9
|
||||
breturn:
|
||||
rts
|
||||
b9:
|
||||
bne breturn
|
||||
lda #$19
|
||||
sta $1103
|
||||
lda $1003
|
||||
@ -88,30 +93,13 @@ animate: {
|
||||
sta $1003
|
||||
lda $1003
|
||||
cmp #$28
|
||||
bcs b11
|
||||
jmp breturn
|
||||
b11:
|
||||
bcc breturn
|
||||
lda $1003
|
||||
sec
|
||||
sbc #$28
|
||||
sta $1003
|
||||
jmp breturn
|
||||
b7:
|
||||
lda #$0
|
||||
sta $1102
|
||||
jmp b8
|
||||
b5:
|
||||
lda #$28
|
||||
sta $1001
|
||||
jmp b6
|
||||
b3:
|
||||
lda #$0
|
||||
sta $1100
|
||||
jmp b4
|
||||
b1:
|
||||
lda #$0
|
||||
sta $1000
|
||||
jmp b2
|
||||
breturn:
|
||||
rts
|
||||
}
|
||||
render: {
|
||||
lda #<$d800
|
||||
@ -161,58 +149,58 @@ findcol: {
|
||||
sta $b
|
||||
lda $9
|
||||
cmp $7
|
||||
beq b2
|
||||
b3:
|
||||
lda $9
|
||||
cmp $7
|
||||
bcc b6
|
||||
lda $9
|
||||
sec
|
||||
sbc $7
|
||||
sta $7
|
||||
b8:
|
||||
bne b2
|
||||
lda $a
|
||||
cmp $b
|
||||
bcc b9
|
||||
lda $a
|
||||
sec
|
||||
sbc $b
|
||||
clc
|
||||
adc $7
|
||||
b11:
|
||||
cmp $6
|
||||
bcc b12
|
||||
b13:
|
||||
inx
|
||||
cpx $8
|
||||
bcc b1
|
||||
jmp breturn
|
||||
breturn_from_b2:
|
||||
bne b2
|
||||
ldy #$0
|
||||
breturn:
|
||||
rts
|
||||
b12:
|
||||
ldy $1200,x
|
||||
sta $6
|
||||
jmp b13
|
||||
b9:
|
||||
b2:
|
||||
lda $9
|
||||
cmp $7
|
||||
bcs b4
|
||||
lda $7
|
||||
sec
|
||||
sbc $9
|
||||
sta $7
|
||||
b5:
|
||||
lda $a
|
||||
cmp $b
|
||||
bcs b6
|
||||
lda $b
|
||||
sec
|
||||
sbc $a
|
||||
clc
|
||||
adc $7
|
||||
jmp b11
|
||||
b6:
|
||||
lda $7
|
||||
sec
|
||||
sbc $9
|
||||
sta $7
|
||||
b7:
|
||||
cmp $6
|
||||
bcs b21
|
||||
ldy $1200,x
|
||||
b8:
|
||||
inx
|
||||
cpx $8
|
||||
bcc b19
|
||||
jmp breturn
|
||||
b19:
|
||||
sta $6
|
||||
jmp b1
|
||||
b21:
|
||||
lda $6
|
||||
jmp b8
|
||||
b2:
|
||||
b6:
|
||||
lda $a
|
||||
cmp $b
|
||||
beq breturn_from_b2
|
||||
jmp b3
|
||||
sec
|
||||
sbc $b
|
||||
clc
|
||||
adc $7
|
||||
jmp b7
|
||||
b4:
|
||||
lda $9
|
||||
sec
|
||||
sbc $7
|
||||
sta $7
|
||||
jmp b5
|
||||
}
|
||||
initscreen: {
|
||||
lda #<$400
|
||||
|
||||
@ -40,64 +40,64 @@ animate: scope:[animate] from main::@10
|
||||
[13] (byte~) animate::$1 ← (byte~) animate::$0 + (byte) 1 [ animate::$1 ]
|
||||
[14] *((word) 4096) ← (byte~) animate::$1 [ ]
|
||||
[15] (byte~) animate::$2 ← * (word) 4096 [ animate::$2 ]
|
||||
[16] if((byte~) animate::$2==(byte) 40) goto animate::@1 [ ]
|
||||
to:animate::@2
|
||||
animate::@2: scope:[animate] from animate animate::@1
|
||||
[17] (byte~) animate::$4 ← * (word) 4352 [ animate::$4 ]
|
||||
[18] (byte~) animate::$5 ← (byte~) animate::$4 + (byte) 1 [ animate::$5 ]
|
||||
[19] *((word) 4352) ← (byte~) animate::$5 [ ]
|
||||
[20] (byte~) animate::$6 ← * (word) 4352 [ animate::$6 ]
|
||||
[21] if((byte~) animate::$6==(byte) 25) goto animate::@3 [ ]
|
||||
to:animate::@4
|
||||
animate::@4: scope:[animate] from animate::@2 animate::@3
|
||||
[22] (byte~) animate::$8 ← * (word) 4097 [ animate::$8 ]
|
||||
[23] (byte~) animate::$9 ← (byte~) animate::$8 - (byte) 1 [ animate::$9 ]
|
||||
[24] *((word) 4097) ← (byte~) animate::$9 [ ]
|
||||
[25] (byte~) animate::$10 ← * (word) 4097 [ animate::$10 ]
|
||||
[26] if((byte~) animate::$10==(byte) 255) goto animate::@5 [ ]
|
||||
to:animate::@6
|
||||
animate::@6: scope:[animate] from animate::@4 animate::@5
|
||||
[27] (byte~) animate::$12 ← * (word) 4354 [ animate::$12 ]
|
||||
[28] (byte~) animate::$13 ← (byte~) animate::$12 + (byte) 1 [ animate::$13 ]
|
||||
[29] *((word) 4354) ← (byte~) animate::$13 [ ]
|
||||
[30] (byte~) animate::$14 ← * (word) 4354 [ animate::$14 ]
|
||||
[31] if((byte~) animate::$14==(byte) 25) goto animate::@7 [ ]
|
||||
[16] if((byte~) animate::$2!=(byte) 40) goto animate::@1 [ ]
|
||||
to:animate::@7
|
||||
animate::@7: scope:[animate] from animate
|
||||
[17] *((word) 4096) ← (byte) 0 [ ]
|
||||
to:animate::@1
|
||||
animate::@1: scope:[animate] from animate animate::@7
|
||||
[18] (byte~) animate::$5 ← * (word) 4352 [ animate::$5 ]
|
||||
[19] (byte~) animate::$6 ← (byte~) animate::$5 + (byte) 1 [ animate::$6 ]
|
||||
[20] *((word) 4352) ← (byte~) animate::$6 [ ]
|
||||
[21] (byte~) animate::$7 ← * (word) 4352 [ animate::$7 ]
|
||||
[22] if((byte~) animate::$7!=(byte) 25) goto animate::@2 [ ]
|
||||
to:animate::@8
|
||||
animate::@8: scope:[animate] from animate::@6 animate::@7
|
||||
[32] (byte~) animate::$16 ← * (word) 4355 [ animate::$16 ]
|
||||
[33] (byte~) animate::$17 ← (byte~) animate::$16 - (byte) 1 [ animate::$17 ]
|
||||
[34] *((word) 4355) ← (byte~) animate::$17 [ ]
|
||||
[35] (byte~) animate::$18 ← * (word) 4355 [ animate::$18 ]
|
||||
[36] if((byte~) animate::$18==(byte) 255) goto animate::@9 [ ]
|
||||
animate::@8: scope:[animate] from animate::@1
|
||||
[23] *((word) 4352) ← (byte) 0 [ ]
|
||||
to:animate::@2
|
||||
animate::@2: scope:[animate] from animate::@1 animate::@8
|
||||
[24] (byte~) animate::$10 ← * (word) 4097 [ animate::$10 ]
|
||||
[25] (byte~) animate::$11 ← (byte~) animate::$10 - (byte) 1 [ animate::$11 ]
|
||||
[26] *((word) 4097) ← (byte~) animate::$11 [ ]
|
||||
[27] (byte~) animate::$12 ← * (word) 4097 [ animate::$12 ]
|
||||
[28] if((byte~) animate::$12!=(byte) 255) goto animate::@3 [ ]
|
||||
to:animate::@9
|
||||
animate::@9: scope:[animate] from animate::@2
|
||||
[29] *((word) 4097) ← (byte) 40 [ ]
|
||||
to:animate::@3
|
||||
animate::@3: scope:[animate] from animate::@2 animate::@9
|
||||
[30] (byte~) animate::$15 ← * (word) 4354 [ animate::$15 ]
|
||||
[31] (byte~) animate::$16 ← (byte~) animate::$15 + (byte) 1 [ animate::$16 ]
|
||||
[32] *((word) 4354) ← (byte~) animate::$16 [ ]
|
||||
[33] (byte~) animate::$17 ← * (word) 4354 [ animate::$17 ]
|
||||
[34] if((byte~) animate::$17!=(byte) 25) goto animate::@4 [ ]
|
||||
to:animate::@10
|
||||
animate::@10: scope:[animate] from animate::@3
|
||||
[35] *((word) 4354) ← (byte) 0 [ ]
|
||||
to:animate::@4
|
||||
animate::@4: scope:[animate] from animate::@10 animate::@3
|
||||
[36] (byte~) animate::$20 ← * (word) 4355 [ animate::$20 ]
|
||||
[37] (byte~) animate::$21 ← (byte~) animate::$20 - (byte) 1 [ animate::$21 ]
|
||||
[38] *((word) 4355) ← (byte~) animate::$21 [ ]
|
||||
[39] (byte~) animate::$22 ← * (word) 4355 [ animate::$22 ]
|
||||
[40] if((byte~) animate::$22!=(byte) 255) goto animate::@return [ ]
|
||||
to:animate::@11
|
||||
animate::@11: scope:[animate] from animate::@4
|
||||
[41] *((word) 4355) ← (byte) 25 [ ]
|
||||
[42] (byte~) animate::$25 ← * (word) 4099 [ animate::$25 ]
|
||||
[43] (byte~) animate::$26 ← (byte~) animate::$25 + (byte) 7 [ animate::$26 ]
|
||||
[44] *((word) 4099) ← (byte~) animate::$26 [ ]
|
||||
[45] (byte~) animate::$27 ← * (word) 4099 [ animate::$27 ]
|
||||
[46] if((byte~) animate::$27<(byte) 40) goto animate::@return [ ]
|
||||
to:animate::@12
|
||||
animate::@12: scope:[animate] from animate::@11
|
||||
[47] (byte~) animate::$30 ← * (word) 4099 [ animate::$30 ]
|
||||
[48] (byte~) animate::$31 ← (byte~) animate::$30 - (byte) 40 [ animate::$31 ]
|
||||
[49] *((word) 4099) ← (byte~) animate::$31 [ ]
|
||||
to:animate::@return
|
||||
animate::@return: scope:[animate] from animate::@11 animate::@8 animate::@9
|
||||
[37] return [ ]
|
||||
animate::@return: scope:[animate] from animate::@11 animate::@12 animate::@4
|
||||
[50] return [ ]
|
||||
to:@return
|
||||
animate::@9: scope:[animate] from animate::@8
|
||||
[38] *((word) 4355) ← (byte) 25 [ ]
|
||||
[39] (byte~) animate::$20 ← * (word) 4099 [ animate::$20 ]
|
||||
[40] (byte~) animate::$21 ← (byte~) animate::$20 + (byte) 7 [ animate::$21 ]
|
||||
[41] *((word) 4099) ← (byte~) animate::$21 [ ]
|
||||
[42] (byte~) animate::$22 ← * (word) 4099 [ animate::$22 ]
|
||||
[43] if((byte~) animate::$22>=(byte) 40) goto animate::@11 [ ]
|
||||
to:animate::@return
|
||||
animate::@11: scope:[animate] from animate::@9
|
||||
[44] (byte~) animate::$24 ← * (word) 4099 [ animate::$24 ]
|
||||
[45] (byte~) animate::$25 ← (byte~) animate::$24 - (byte) 40 [ animate::$25 ]
|
||||
[46] *((word) 4099) ← (byte~) animate::$25 [ ]
|
||||
to:animate::@return
|
||||
animate::@7: scope:[animate] from animate::@6
|
||||
[47] *((word) 4354) ← (byte) 0 [ ]
|
||||
to:animate::@8
|
||||
animate::@5: scope:[animate] from animate::@4
|
||||
[48] *((word) 4097) ← (byte) 40 [ ]
|
||||
to:animate::@6
|
||||
animate::@3: scope:[animate] from animate::@2
|
||||
[49] *((word) 4352) ← (byte) 0 [ ]
|
||||
to:animate::@4
|
||||
animate::@1: scope:[animate] from animate
|
||||
[50] *((word) 4096) ← (byte) 0 [ ]
|
||||
to:animate::@2
|
||||
render: scope:[render] from main::@1
|
||||
to:render::@1
|
||||
render::@1: scope:[render] from render render::@3
|
||||
@ -126,77 +126,82 @@ render::@return: scope:[render] from render::@3
|
||||
to:@return
|
||||
findcol: scope:[findcol] from render::@2
|
||||
to:findcol::@1
|
||||
findcol::@1: scope:[findcol] from findcol findcol::@13
|
||||
[64] (byte) findcol::mincol#11 ← phi( findcol/(byte) 0 findcol::@13/(byte) findcol::mincol#2 ) [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
[64] (byte) findcol::mindiff#10 ← phi( findcol/(byte) 255 findcol::@13/(byte) findcol::mindiff#11 ) [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
[64] (byte) findcol::i#12 ← phi( findcol/(byte) 0 findcol::@13/(byte) findcol::i#1 ) [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
findcol::@1: scope:[findcol] from findcol findcol::@19
|
||||
[64] (byte) findcol::mincol#11 ← phi( findcol/(byte) 0 findcol::@19/(byte) findcol::mincol#2 ) [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
[64] (byte) findcol::mindiff#10 ← phi( findcol/(byte) 255 findcol::@19/(byte~) findcol::mindiff#13 ) [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
[64] (byte) findcol::i#12 ← phi( findcol/(byte) 0 findcol::@19/(byte) findcol::i#1 ) [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
[65] (byte) findcol::xp#0 ← (word) 4096 *idx (byte) findcol::i#12 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::xp#0 findcol::y#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
[66] (byte) findcol::yp#0 ← (word) 4352 *idx (byte) findcol::i#12 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::xp#0 findcol::y#0 findcol::yp#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
[67] if((byte) findcol::x#0==(byte) findcol::xp#0) goto findcol::@2 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::xp#0 findcol::y#0 findcol::yp#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
to:findcol::@3
|
||||
findcol::@3: scope:[findcol] from findcol::@1 findcol::@2
|
||||
[68] if((byte) findcol::x#0<(byte) findcol::xp#0) goto findcol::@6 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::xp#0 findcol::y#0 findcol::yp#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
to:findcol::@7
|
||||
findcol::@7: scope:[findcol] from findcol::@3
|
||||
[69] (byte) findcol::diff#1 ← (byte) findcol::x#0 - (byte) findcol::xp#0 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::diff#1 findcol::y#0 findcol::yp#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
to:findcol::@8
|
||||
findcol::@8: scope:[findcol] from findcol::@6 findcol::@7
|
||||
[70] (byte) findcol::diff#4 ← phi( findcol::@6/(byte) findcol::diff#0 findcol::@7/(byte) findcol::diff#1 ) [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::yp#0 findcol::diff#4 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
[71] if((byte) findcol::y#0<(byte) findcol::yp#0) goto findcol::@9 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::yp#0 findcol::diff#4 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
to:findcol::@10
|
||||
findcol::@10: scope:[findcol] from findcol::@8
|
||||
[72] (byte~) findcol::$10 ← (byte) findcol::y#0 - (byte) findcol::yp#0 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#4 findcol::$10 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
[73] (byte) findcol::diff#3 ← (byte) findcol::diff#4 + (byte~) findcol::$10 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#3 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
to:findcol::@11
|
||||
findcol::@11: scope:[findcol] from findcol::@10 findcol::@9
|
||||
[74] (byte) findcol::diff#6 ← phi( findcol::@10/(byte) findcol::diff#3 findcol::@9/(byte) findcol::diff#2 ) [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#6 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
[75] if((byte) findcol::diff#6<(byte) findcol::mindiff#10) goto findcol::@12 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#6 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
to:findcol::@13
|
||||
findcol::@13: scope:[findcol] from findcol::@11 findcol::@12
|
||||
[76] (byte) findcol::mindiff#11 ← phi( findcol::@11/(byte) findcol::mindiff#10 findcol::@12/(byte~) findcol::diff#13 ) [ render::x#2 render::y#2 render::colline#2 findcol::mindiff#11 findcol::mincol#2 findcol::i#12 findcol::x#0 findcol::y#0 numpoints#1 ]
|
||||
[76] (byte) findcol::mincol#2 ← phi( findcol::@11/(byte) findcol::mincol#11 findcol::@12/(byte) findcol::mincol#1 ) [ render::x#2 render::y#2 render::colline#2 findcol::mindiff#11 findcol::mincol#2 findcol::i#12 findcol::x#0 findcol::y#0 numpoints#1 ]
|
||||
[77] (byte) findcol::i#1 ← ++ (byte) findcol::i#12 [ render::x#2 render::y#2 render::colline#2 findcol::i#1 findcol::mindiff#11 findcol::mincol#2 findcol::x#0 findcol::y#0 numpoints#1 ]
|
||||
[78] if((byte) findcol::i#1<(byte) numpoints#1) goto findcol::@1 [ render::x#2 render::y#2 render::colline#2 findcol::i#1 findcol::mindiff#11 findcol::mincol#2 findcol::x#0 findcol::y#0 numpoints#1 ]
|
||||
[67] if((byte) findcol::x#0!=(byte) findcol::xp#0) goto findcol::@2 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::xp#0 findcol::y#0 findcol::yp#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
to:findcol::@9
|
||||
findcol::@9: scope:[findcol] from findcol::@1
|
||||
[68] if((byte) findcol::y#0!=(byte) findcol::yp#0) goto findcol::@2 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::xp#0 findcol::y#0 findcol::yp#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
to:findcol::@return
|
||||
findcol::@return: scope:[findcol] from findcol::@13 findcol::@2
|
||||
[79] (byte) findcol::return#0 ← phi( findcol::@13/(byte) findcol::mincol#2 findcol::@2/(byte) 0 ) [ render::x#2 render::y#2 findcol::return#0 render::colline#2 ]
|
||||
[80] return [ render::x#2 render::y#2 findcol::return#0 render::colline#2 ]
|
||||
findcol::@return: scope:[findcol] from findcol::@8 findcol::@9
|
||||
[69] (byte) findcol::return#0 ← phi( findcol::@8/(byte) findcol::mincol#2 findcol::@9/(byte) 0 ) [ render::x#2 render::y#2 findcol::return#0 render::colline#2 ]
|
||||
[70] return [ render::x#2 render::y#2 findcol::return#0 render::colline#2 ]
|
||||
to:@return
|
||||
findcol::@12: scope:[findcol] from findcol::@11
|
||||
[81] (byte) findcol::mincol#1 ← (word) 4608 *idx (byte) findcol::i#12 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#6 findcol::mincol#1 numpoints#1 ]
|
||||
[82] (byte~) findcol::diff#13 ← (byte) findcol::diff#6 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::mincol#1 findcol::diff#13 numpoints#1 ]
|
||||
to:findcol::@13
|
||||
findcol::@9: scope:[findcol] from findcol::@8
|
||||
[83] (byte~) findcol::$8 ← (byte) findcol::yp#0 - (byte) findcol::y#0 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#4 findcol::mindiff#10 findcol::mincol#11 numpoints#1 findcol::$8 ]
|
||||
[84] (byte) findcol::diff#2 ← (byte) findcol::diff#4 + (byte~) findcol::$8 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#2 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
to:findcol::@11
|
||||
findcol::@6: scope:[findcol] from findcol::@3
|
||||
[85] (byte) findcol::diff#0 ← (byte) findcol::xp#0 - (byte) findcol::x#0 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::diff#0 findcol::y#0 findcol::yp#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
findcol::@2: scope:[findcol] from findcol::@1 findcol::@9
|
||||
[71] if((byte) findcol::x#0>=(byte) findcol::xp#0) goto findcol::@4 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::xp#0 findcol::y#0 findcol::yp#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
to:findcol::@12
|
||||
findcol::@12: scope:[findcol] from findcol::@2
|
||||
[72] (byte) findcol::diff#1 ← (byte) findcol::xp#0 - (byte) findcol::x#0 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::yp#0 findcol::diff#1 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
to:findcol::@5
|
||||
findcol::@5: scope:[findcol] from findcol::@12 findcol::@4
|
||||
[73] (byte) findcol::diff#4 ← phi( findcol::@12/(byte) findcol::diff#1 findcol::@4/(byte) findcol::diff#0 ) [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::yp#0 findcol::diff#4 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
[74] if((byte) findcol::y#0>=(byte) findcol::yp#0) goto findcol::@6 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::yp#0 findcol::diff#4 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
to:findcol::@14
|
||||
findcol::@14: scope:[findcol] from findcol::@5
|
||||
[75] (byte~) findcol::$12 ← (byte) findcol::yp#0 - (byte) findcol::y#0 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#4 findcol::$12 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
[76] (byte) findcol::diff#3 ← (byte) findcol::diff#4 + (byte~) findcol::$12 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#3 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
to:findcol::@7
|
||||
findcol::@7: scope:[findcol] from findcol::@14 findcol::@6
|
||||
[77] (byte) findcol::diff#6 ← phi( findcol::@14/(byte) findcol::diff#3 findcol::@6/(byte) findcol::diff#2 ) [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#6 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
[78] if((byte) findcol::diff#6>=(byte) findcol::mindiff#10) goto findcol::@21 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#6 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
to:findcol::@16
|
||||
findcol::@16: scope:[findcol] from findcol::@7
|
||||
[79] (byte) findcol::mincol#1 ← (word) 4608 *idx (byte) findcol::i#12 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#6 findcol::mincol#1 numpoints#1 ]
|
||||
to:findcol::@8
|
||||
findcol::@2: scope:[findcol] from findcol::@1
|
||||
[86] if((byte) findcol::y#0==(byte) findcol::yp#0) goto findcol::@return [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::xp#0 findcol::y#0 findcol::yp#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
to:findcol::@3
|
||||
findcol::@8: scope:[findcol] from findcol::@16 findcol::@21
|
||||
[80] (byte) findcol::mindiff#11 ← phi( findcol::@16/(byte) findcol::diff#6 findcol::@21/(byte~) findcol::mindiff#14 ) [ render::x#2 render::y#2 render::colline#2 findcol::mincol#2 findcol::i#12 findcol::x#0 findcol::y#0 numpoints#1 findcol::mindiff#11 ]
|
||||
[80] (byte) findcol::mincol#2 ← phi( findcol::@16/(byte) findcol::mincol#1 findcol::@21/(byte) findcol::mincol#11 ) [ render::x#2 render::y#2 render::colline#2 findcol::mincol#2 findcol::i#12 findcol::x#0 findcol::y#0 numpoints#1 findcol::mindiff#11 ]
|
||||
[81] (byte) findcol::i#1 ← ++ (byte) findcol::i#12 [ render::x#2 render::y#2 render::colline#2 findcol::i#1 findcol::mincol#2 findcol::x#0 findcol::y#0 numpoints#1 findcol::mindiff#11 ]
|
||||
[82] if((byte) findcol::i#1<(byte) numpoints#1) goto findcol::@19 [ render::x#2 render::y#2 render::colline#2 findcol::i#1 findcol::mincol#2 findcol::x#0 findcol::y#0 numpoints#1 findcol::mindiff#11 ]
|
||||
to:findcol::@return
|
||||
findcol::@19: scope:[findcol] from findcol::@8
|
||||
[83] (byte~) findcol::mindiff#13 ← (byte) findcol::mindiff#11 [ render::x#2 render::y#2 render::colline#2 findcol::i#1 findcol::mindiff#13 findcol::mincol#2 findcol::x#0 findcol::y#0 numpoints#1 ]
|
||||
to:findcol::@1
|
||||
findcol::@21: scope:[findcol] from findcol::@7
|
||||
[84] (byte~) findcol::mindiff#14 ← (byte) findcol::mindiff#10 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::mincol#11 findcol::mindiff#14 numpoints#1 ]
|
||||
to:findcol::@8
|
||||
findcol::@6: scope:[findcol] from findcol::@5
|
||||
[85] (byte~) findcol::$14 ← (byte) findcol::y#0 - (byte) findcol::yp#0 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#4 findcol::mindiff#10 findcol::mincol#11 numpoints#1 findcol::$14 ]
|
||||
[86] (byte) findcol::diff#2 ← (byte) findcol::diff#4 + (byte~) findcol::$14 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#2 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
to:findcol::@7
|
||||
findcol::@4: scope:[findcol] from findcol::@2
|
||||
[87] (byte) findcol::diff#0 ← (byte) findcol::x#0 - (byte) findcol::xp#0 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::yp#0 findcol::diff#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
|
||||
to:findcol::@5
|
||||
initscreen: scope:[initscreen] from main::@8
|
||||
to:initscreen::@1
|
||||
initscreen::@1: scope:[initscreen] from initscreen initscreen::@1
|
||||
[87] (byte*) initscreen::screen#2 ← phi( initscreen/(word) 1024 initscreen::@1/(byte*) initscreen::screen#1 ) [ initscreen::screen#2 ]
|
||||
[88] *((byte*) initscreen::screen#2) ← (byte) 230 [ initscreen::screen#2 ]
|
||||
[89] (byte*) initscreen::screen#1 ← ++ (byte*) initscreen::screen#2 [ initscreen::screen#1 ]
|
||||
[90] if((byte*) initscreen::screen#1<(word) 2024) goto initscreen::@1 [ initscreen::screen#1 ]
|
||||
[88] (byte*) initscreen::screen#2 ← phi( initscreen/(word) 1024 initscreen::@1/(byte*) initscreen::screen#1 ) [ initscreen::screen#2 ]
|
||||
[89] *((byte*) initscreen::screen#2) ← (byte) 230 [ initscreen::screen#2 ]
|
||||
[90] (byte*) initscreen::screen#1 ← ++ (byte*) initscreen::screen#2 [ initscreen::screen#1 ]
|
||||
[91] if((byte*) initscreen::screen#1<(word) 2024) goto initscreen::@1 [ initscreen::screen#1 ]
|
||||
to:initscreen::@return
|
||||
initscreen::@return: scope:[initscreen] from initscreen::@1
|
||||
[91] return [ ]
|
||||
[92] return [ ]
|
||||
to:@return
|
||||
addpoint: scope:[addpoint] from main main::@3 main::@4 main::@5 main::@6 main::@7
|
||||
[92] (byte) addpoint::c#6 ← phi( main/(byte) 1 main::@3/(byte) 2 main::@4/(byte) 3 main::@5/(byte) 4 main::@6/(byte) 5 main::@7/(byte) 7 ) [ numpoints#19 addpoint::x#6 addpoint::y#6 addpoint::c#6 ]
|
||||
[92] (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 ) [ numpoints#19 addpoint::x#6 addpoint::y#6 addpoint::c#6 ]
|
||||
[92] (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 ) [ numpoints#19 addpoint::x#6 addpoint::y#6 addpoint::c#6 ]
|
||||
[92] (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 ) [ numpoints#19 addpoint::x#6 addpoint::y#6 addpoint::c#6 ]
|
||||
[93] *((word) 4096 + (byte) numpoints#19) ← (byte) addpoint::x#6 [ numpoints#19 addpoint::y#6 addpoint::c#6 ]
|
||||
[94] *((word) 4352 + (byte) numpoints#19) ← (byte) addpoint::y#6 [ numpoints#19 addpoint::c#6 ]
|
||||
[95] *((word) 4608 + (byte) numpoints#19) ← (byte) addpoint::c#6 [ numpoints#19 ]
|
||||
[96] (byte) numpoints#1 ← ++ (byte) numpoints#19 [ ]
|
||||
[93] (byte) addpoint::c#6 ← phi( main/(byte) 1 main::@3/(byte) 2 main::@4/(byte) 3 main::@5/(byte) 4 main::@6/(byte) 5 main::@7/(byte) 7 ) [ numpoints#19 addpoint::x#6 addpoint::y#6 addpoint::c#6 ]
|
||||
[93] (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 ) [ numpoints#19 addpoint::x#6 addpoint::y#6 addpoint::c#6 ]
|
||||
[93] (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 ) [ numpoints#19 addpoint::x#6 addpoint::y#6 addpoint::c#6 ]
|
||||
[93] (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 ) [ numpoints#19 addpoint::x#6 addpoint::y#6 addpoint::c#6 ]
|
||||
[94] *((word) 4096 + (byte) numpoints#19) ← (byte) addpoint::x#6 [ numpoints#19 addpoint::y#6 addpoint::c#6 ]
|
||||
[95] *((word) 4352 + (byte) numpoints#19) ← (byte) addpoint::y#6 [ numpoints#19 addpoint::c#6 ]
|
||||
[96] *((word) 4608 + (byte) numpoints#19) ← (byte) addpoint::c#6 [ numpoints#19 ]
|
||||
[97] (byte) numpoints#1 ← ++ (byte) numpoints#19 [ ]
|
||||
to:addpoint::@return
|
||||
addpoint::@return: scope:[addpoint] from addpoint
|
||||
[97] return [ ]
|
||||
[98] return [ ]
|
||||
to:@return
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -17,45 +17,47 @@
|
||||
(void()) animate()
|
||||
(byte~) animate::$0 reg byte a 4.0
|
||||
(byte~) animate::$1 reg byte a 4.0
|
||||
(byte~) animate::$10 reg byte a 4.0
|
||||
(byte~) animate::$10 reg byte x 4.0
|
||||
(byte~) animate::$11 reg byte x 4.0
|
||||
(byte~) animate::$12 reg byte a 4.0
|
||||
(byte~) animate::$13 reg byte a 4.0
|
||||
(byte~) animate::$14 reg byte a 4.0
|
||||
(byte~) animate::$16 reg byte x 4.0
|
||||
(byte~) animate::$17 reg byte x 4.0
|
||||
(byte~) animate::$18 reg byte a 4.0
|
||||
(byte~) animate::$15 reg byte a 4.0
|
||||
(byte~) animate::$16 reg byte a 4.0
|
||||
(byte~) animate::$17 reg byte a 4.0
|
||||
(byte~) animate::$2 reg byte a 4.0
|
||||
(byte~) animate::$20 reg byte a 4.0
|
||||
(byte~) animate::$21 reg byte a 4.0
|
||||
(byte~) animate::$20 reg byte x 4.0
|
||||
(byte~) animate::$21 reg byte x 4.0
|
||||
(byte~) animate::$22 reg byte a 4.0
|
||||
(byte~) animate::$24 reg byte a 4.0
|
||||
(byte~) animate::$25 reg byte a 4.0
|
||||
(byte~) animate::$4 reg byte a 4.0
|
||||
(byte~) animate::$26 reg byte a 4.0
|
||||
(byte~) animate::$27 reg byte a 4.0
|
||||
(byte~) animate::$30 reg byte a 4.0
|
||||
(byte~) animate::$31 reg byte a 4.0
|
||||
(byte~) animate::$5 reg byte a 4.0
|
||||
(byte~) animate::$6 reg byte a 4.0
|
||||
(byte~) animate::$8 reg byte x 4.0
|
||||
(byte~) animate::$9 reg byte x 4.0
|
||||
(byte~) animate::$7 reg byte a 4.0
|
||||
(label) animate::@1
|
||||
(label) animate::@10
|
||||
(label) animate::@11
|
||||
(label) animate::@12
|
||||
(label) animate::@2
|
||||
(label) animate::@3
|
||||
(label) animate::@4
|
||||
(label) animate::@5
|
||||
(label) animate::@6
|
||||
(label) animate::@7
|
||||
(label) animate::@8
|
||||
(label) animate::@9
|
||||
(label) animate::@return
|
||||
(byte()) findcol((byte) findcol::x , (byte) findcol::y)
|
||||
(byte~) findcol::$10 reg byte a 20002.0
|
||||
(byte~) findcol::$8 reg byte a 20002.0
|
||||
(byte~) findcol::$12 reg byte a 20002.0
|
||||
(byte~) findcol::$14 reg byte a 20002.0
|
||||
(label) findcol::@1
|
||||
(label) findcol::@10
|
||||
(label) findcol::@11
|
||||
(label) findcol::@12
|
||||
(label) findcol::@13
|
||||
(label) findcol::@14
|
||||
(label) findcol::@16
|
||||
(label) findcol::@19
|
||||
(label) findcol::@2
|
||||
(label) findcol::@3
|
||||
(label) findcol::@21
|
||||
(label) findcol::@4
|
||||
(label) findcol::@5
|
||||
(label) findcol::@6
|
||||
(label) findcol::@7
|
||||
(label) findcol::@8
|
||||
@ -64,29 +66,30 @@
|
||||
(byte) findcol::diff
|
||||
(byte) findcol::diff#0 zp byte:7 20002.0
|
||||
(byte) findcol::diff#1 zp byte:7 20002.0
|
||||
(byte~) findcol::diff#13 zp byte:6 20002.0
|
||||
(byte) findcol::diff#2 reg byte a 20002.0
|
||||
(byte) findcol::diff#3 reg byte a 20002.0
|
||||
(byte) findcol::diff#4 zp byte:7 10001.0
|
||||
(byte) findcol::diff#6 reg byte a 13334.666666666666
|
||||
(byte) findcol::i
|
||||
(byte) findcol::i#1 reg byte x 15001.5
|
||||
(byte) findcol::i#1 reg byte x 10001.0
|
||||
(byte) findcol::i#12 reg byte x 2631.842105263158
|
||||
(byte) findcol::mincol
|
||||
(byte) findcol::mincol#1 reg byte y 10001.0
|
||||
(byte) findcol::mincol#11 reg byte y 1250.125
|
||||
(byte) findcol::mincol#2 reg byte y 13334.666666666666
|
||||
(byte) findcol::mincol#1 reg byte y 20002.0
|
||||
(byte) findcol::mincol#11 reg byte y 1176.5882352941176
|
||||
(byte) findcol::mincol#2 reg byte y 10001.0
|
||||
(byte) findcol::mindiff
|
||||
(byte) findcol::mindiff#10 zp byte:6 1875.1875
|
||||
(byte) findcol::mindiff#11 zp byte:6 10001.0
|
||||
(byte) findcol::mindiff#11 reg byte a 10001.0
|
||||
(byte~) findcol::mindiff#13 zp byte:6 20002.0
|
||||
(byte~) findcol::mindiff#14 reg byte a 20002.0
|
||||
(byte) findcol::return
|
||||
(byte) findcol::return#0 reg byte y 3667.333333333333
|
||||
(byte) findcol::x
|
||||
(byte) findcol::x#0 zp byte:9 1952.6190476190475
|
||||
(byte) findcol::x#0 zp byte:9 1863.8636363636363
|
||||
(byte) findcol::xp
|
||||
(byte) findcol::xp#0 zp byte:7 10001.0
|
||||
(byte) findcol::y
|
||||
(byte) findcol::y#0 zp byte:10 1952.6190476190475
|
||||
(byte) findcol::y#0 zp byte:10 1863.8636363636363
|
||||
(byte) findcol::yp
|
||||
(byte) findcol::yp#0 zp byte:11 6250.625
|
||||
(void()) initscreen()
|
||||
@ -107,7 +110,7 @@
|
||||
(label) main::@8
|
||||
(label) main::@return
|
||||
(byte) numpoints
|
||||
(byte) numpoints#1 zp byte:8 476.8095238095237
|
||||
(byte) numpoints#1 zp byte:8 455.13636363636346
|
||||
(byte) numpoints#19 zp byte:8 4.5
|
||||
(void()) render()
|
||||
(label) render::@1
|
||||
@ -119,48 +122,48 @@
|
||||
(byte) render::col#0 reg byte a 2002.0
|
||||
(byte*) render::colline
|
||||
(byte*) render::colline#1 zp ptr byte:3 67.33333333333333
|
||||
(byte*) render::colline#2 zp ptr byte:3 37.59375
|
||||
(byte*) render::colline#2 zp ptr byte:3 36.45454545454545
|
||||
(byte) render::x
|
||||
(byte) render::x#1 zp byte:5 1501.5
|
||||
(byte) render::x#2 zp byte:5 138.06896551724137
|
||||
(byte) render::x#2 zp byte:5 133.46666666666667
|
||||
(byte) render::y
|
||||
(byte) render::y#1 zp byte:2 151.5
|
||||
(byte) render::y#2 zp byte:2 36.45454545454545
|
||||
(byte) render::y#2 zp byte:2 35.38235294117647
|
||||
|
||||
zp byte:2 [ render::y#2 render::y#1 addpoint::c#6 ]
|
||||
zp ptr byte:3 [ render::colline#2 render::colline#1 initscreen::screen#2 initscreen::screen#1 ]
|
||||
zp byte:5 [ render::x#2 render::x#1 ]
|
||||
reg byte x [ findcol::i#12 findcol::i#1 ]
|
||||
zp byte:6 [ findcol::mindiff#10 findcol::mindiff#11 findcol::diff#13 ]
|
||||
zp byte:7 [ findcol::diff#4 findcol::diff#0 findcol::diff#1 findcol::xp#0 ]
|
||||
reg byte a [ findcol::diff#6 findcol::diff#3 findcol::diff#2 ]
|
||||
zp byte:6 [ findcol::mindiff#10 findcol::mindiff#13 ]
|
||||
reg byte y [ findcol::return#0 findcol::mincol#11 findcol::mincol#2 findcol::mincol#1 ]
|
||||
zp byte:7 [ findcol::diff#4 findcol::diff#1 findcol::diff#0 findcol::xp#0 ]
|
||||
reg byte a [ findcol::mindiff#11 findcol::diff#6 findcol::diff#3 findcol::diff#2 findcol::mindiff#14 ]
|
||||
reg byte a [ addpoint::x#6 ]
|
||||
zp byte:8 [ numpoints#19 numpoints#1 ]
|
||||
reg byte y [ addpoint::y#6 ]
|
||||
reg byte a [ animate::$0 ]
|
||||
reg byte a [ animate::$1 ]
|
||||
reg byte a [ animate::$2 ]
|
||||
reg byte a [ animate::$4 ]
|
||||
reg byte a [ animate::$5 ]
|
||||
reg byte a [ animate::$6 ]
|
||||
reg byte x [ animate::$8 ]
|
||||
reg byte x [ animate::$9 ]
|
||||
reg byte a [ animate::$10 ]
|
||||
reg byte a [ animate::$7 ]
|
||||
reg byte x [ animate::$10 ]
|
||||
reg byte x [ animate::$11 ]
|
||||
reg byte a [ animate::$12 ]
|
||||
reg byte a [ animate::$13 ]
|
||||
reg byte a [ animate::$14 ]
|
||||
reg byte x [ animate::$16 ]
|
||||
reg byte x [ animate::$17 ]
|
||||
reg byte a [ animate::$18 ]
|
||||
reg byte a [ animate::$20 ]
|
||||
reg byte a [ animate::$21 ]
|
||||
reg byte a [ animate::$15 ]
|
||||
reg byte a [ animate::$16 ]
|
||||
reg byte a [ animate::$17 ]
|
||||
reg byte x [ animate::$20 ]
|
||||
reg byte x [ animate::$21 ]
|
||||
reg byte a [ animate::$22 ]
|
||||
reg byte a [ animate::$24 ]
|
||||
reg byte a [ animate::$25 ]
|
||||
reg byte a [ animate::$26 ]
|
||||
reg byte a [ animate::$27 ]
|
||||
reg byte a [ animate::$30 ]
|
||||
reg byte a [ animate::$31 ]
|
||||
zp byte:9 [ findcol::x#0 ]
|
||||
zp byte:10 [ findcol::y#0 ]
|
||||
reg byte a [ render::col#0 ]
|
||||
zp byte:11 [ findcol::yp#0 ]
|
||||
reg byte a [ findcol::$10 ]
|
||||
reg byte a [ findcol::$8 ]
|
||||
reg byte a [ findcol::$12 ]
|
||||
reg byte a [ findcol::$14 ]
|
||||
|
||||
Loading…
Reference in New Issue
Block a user