From 3658d9f68e256af698e1a4519602430f4947a910 Mon Sep 17 00:00:00 2001 From: jespergravgaard Date: Thu, 2 Aug 2018 02:53:52 +0200 Subject: [PATCH] Implemented sorter inside a multiplexer. --- ...derefidx_pbuc2_derefidx_vbuxx_then_la1.asm | 3 + ...derefidx_pbuc2_derefidx_vbuyy_then_la1.asm | 3 + .../Pass2ConditionalAndOrRewriting.java | 30 +- .../kickc/passes/Pass2SsaOptimization.java | 2 +- .../passes/Pass2UnaryNotSimplification.java | 2 +- .../kickc/passes/Pass3PhiLifting.java | 2 +- .../dk/camelot64/kickc/test/TestPrograms.java | 5 + .../dk/camelot64/kickc/test/kc/multiplexer.kc | 83 + .../dk/camelot64/kickc/test/kc/scrolllogo.kc | 5 +- .../camelot64/kickc/test/ref/multiplexer.asm | 163 + .../camelot64/kickc/test/ref/multiplexer.cfg | 147 + .../camelot64/kickc/test/ref/multiplexer.log | 3359 +++++++++++++++++ .../camelot64/kickc/test/ref/multiplexer.sym | 101 + .../camelot64/kickc/test/ref/scrolllogo.log | 5 +- 14 files changed, 3893 insertions(+), 17 deletions(-) create mode 100644 src/main/java/dk/camelot64/kickc/fragment/asm/vbuaa_lt_pbuc1_derefidx_pbuc2_derefidx_vbuxx_then_la1.asm create mode 100644 src/main/java/dk/camelot64/kickc/fragment/asm/vbuaa_lt_pbuc1_derefidx_pbuc2_derefidx_vbuyy_then_la1.asm create mode 100644 src/test/java/dk/camelot64/kickc/test/kc/multiplexer.kc create mode 100644 src/test/java/dk/camelot64/kickc/test/ref/multiplexer.asm create mode 100644 src/test/java/dk/camelot64/kickc/test/ref/multiplexer.cfg create mode 100644 src/test/java/dk/camelot64/kickc/test/ref/multiplexer.log create mode 100644 src/test/java/dk/camelot64/kickc/test/ref/multiplexer.sym diff --git a/src/main/java/dk/camelot64/kickc/fragment/asm/vbuaa_lt_pbuc1_derefidx_pbuc2_derefidx_vbuxx_then_la1.asm b/src/main/java/dk/camelot64/kickc/fragment/asm/vbuaa_lt_pbuc1_derefidx_pbuc2_derefidx_vbuxx_then_la1.asm new file mode 100644 index 000000000..799cde50c --- /dev/null +++ b/src/main/java/dk/camelot64/kickc/fragment/asm/vbuaa_lt_pbuc1_derefidx_pbuc2_derefidx_vbuxx_then_la1.asm @@ -0,0 +1,3 @@ +ldy {c2},x +cmp {c1},y +bcc {la1} diff --git a/src/main/java/dk/camelot64/kickc/fragment/asm/vbuaa_lt_pbuc1_derefidx_pbuc2_derefidx_vbuyy_then_la1.asm b/src/main/java/dk/camelot64/kickc/fragment/asm/vbuaa_lt_pbuc1_derefidx_pbuc2_derefidx_vbuyy_then_la1.asm new file mode 100644 index 000000000..b03f2775a --- /dev/null +++ b/src/main/java/dk/camelot64/kickc/fragment/asm/vbuaa_lt_pbuc1_derefidx_pbuc2_derefidx_vbuyy_then_la1.asm @@ -0,0 +1,3 @@ +ldx {c2},y +cmp {c1},x +bcc {la1} diff --git a/src/main/java/dk/camelot64/kickc/passes/Pass2ConditionalAndOrRewriting.java b/src/main/java/dk/camelot64/kickc/passes/Pass2ConditionalAndOrRewriting.java index 5e54d5195..999f36c38 100644 --- a/src/main/java/dk/camelot64/kickc/passes/Pass2ConditionalAndOrRewriting.java +++ b/src/main/java/dk/camelot64/kickc/passes/Pass2ConditionalAndOrRewriting.java @@ -10,10 +10,7 @@ import dk.camelot64.kickc.model.symbols.Label; import dk.camelot64.kickc.model.symbols.Scope; import dk.camelot64.kickc.model.values.*; -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; -import java.util.Map; +import java.util.*; /** * Compiler Pass rewriting conditional jumps that use && or || operators @@ -91,13 +88,21 @@ public class Pass2ConditionalAndOrRewriting extends Pass2SsaOptimization { Label newBlockLabel = currentScope.addLabelIntermediate(); ControlFlowBlock newBlock = new ControlFlowBlock(newBlockLabel.getRef(), currentScopeRef); getGraph().addBlock(newBlock); - newBlock.getStatements().add(new StatementConditionalJump(conditionAssignment.getrValue2(), conditional.getDestination(), conditional.getSource())); + LabelRef destLabel = conditional.getDestination(); + newBlock.getStatements().add(new StatementConditionalJump(conditionAssignment.getrValue2(), destLabel, conditional.getSource())); newBlock.setDefaultSuccessor(block.getDefaultSuccessor()); - newBlock.setConditionalSuccessor(conditional.getDestination()); + newBlock.setConditionalSuccessor(destLabel); // Rewrite the conditional to use only the first part of the && condition expression conditional.setDestination(newBlockLabel.getRef()); block.setConditionalSuccessor(newBlockLabel.getRef()); conditional.setrValue2(conditionAssignment.getrValue1()); + + // Replace the phi labels inside the destination block with the new block + ControlFlowBlock destBlock = getGraph().getBlock(destLabel); + LinkedHashMap replacements = new LinkedHashMap<>(); + replacements.put(block.getLabel(), newBlockLabel.getRef()); + replaceLabels(destBlock, replacements); + } /** @@ -120,6 +125,19 @@ public class Pass2ConditionalAndOrRewriting extends Pass2SsaOptimization { // Rewrite the conditional to use only the first part of the && condition expression block.setDefaultSuccessor(newBlockLabel.getRef()); conditional.setrValue2(conditionAssignment.getrValue1()); + + + // TODO: Fix phi-values inside the destination phi-blocks to reflect the new control flow! Use replaceLabels(block, replacement) + ControlFlowBlock conditionalDestBlock = getGraph().getBlock(conditional.getDestination()); + if(conditionalDestBlock.hasPhiBlock()) { + throw new RuntimeException("TODO: Fix phi-values inside the conditional destination phi-block!"); + } + ControlFlowBlock defaultDestBlock = getGraph().getBlock(newBlock.getDefaultSuccessor()); + if(defaultDestBlock.hasPhiBlock()) { + throw new RuntimeException("TODO: Fix phi-values inside the default destination phi-block!"); + } + + } /** diff --git a/src/main/java/dk/camelot64/kickc/passes/Pass2SsaOptimization.java b/src/main/java/dk/camelot64/kickc/passes/Pass2SsaOptimization.java index 4d9ab0e58..5f1cfb278 100644 --- a/src/main/java/dk/camelot64/kickc/passes/Pass2SsaOptimization.java +++ b/src/main/java/dk/camelot64/kickc/passes/Pass2SsaOptimization.java @@ -59,7 +59,7 @@ public abstract class Pass2SsaOptimization extends Pass1Base { visitor.visitBlock(block); } - /** Creates a visitor that can getReplacement labels. */ + /** Creates a visitor that can replace labels. */ private ControlFlowGraphBaseVisitor getLabelReplaceVisitor(final Map replacements) { return new ControlFlowGraphBaseVisitor() { diff --git a/src/main/java/dk/camelot64/kickc/passes/Pass2UnaryNotSimplification.java b/src/main/java/dk/camelot64/kickc/passes/Pass2UnaryNotSimplification.java index d9153450d..3eb51161c 100644 --- a/src/main/java/dk/camelot64/kickc/passes/Pass2UnaryNotSimplification.java +++ b/src/main/java/dk/camelot64/kickc/passes/Pass2UnaryNotSimplification.java @@ -33,7 +33,7 @@ public class Pass2UnaryNotSimplification extends Pass2SsaOptimization { } /** - * Examine all unary nots. If they are the only usage of a reversable unary not getReplacement the unary not with the reversed comparison - and eliminate the riginal variable. + * 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 diff --git a/src/main/java/dk/camelot64/kickc/passes/Pass3PhiLifting.java b/src/main/java/dk/camelot64/kickc/passes/Pass3PhiLifting.java index 708533423..700fb8533 100644 --- a/src/main/java/dk/camelot64/kickc/passes/Pass3PhiLifting.java +++ b/src/main/java/dk/camelot64/kickc/passes/Pass3PhiLifting.java @@ -63,7 +63,7 @@ public class Pass3PhiLifting { } StatementAssignment newAssignment = new StatementAssignment(newVar.getRef(), phiRValue.getrValue(), phiBlock.getSource()); if(lastPredecessorStatement instanceof StatementConditionalJump) { - // Use or Create a new block between the predecessor and this one - getReplacement labels where appropriate + // Use or Create a new block between the predecessor and this one - replace labels where appropriate ControlFlowBlock newBlock; LabelRef newBlockRef = newBlocks.get(predecessorRef); if(newBlockRef == null) { diff --git a/src/test/java/dk/camelot64/kickc/test/TestPrograms.java b/src/test/java/dk/camelot64/kickc/test/TestPrograms.java index f675a4270..d28706c7b 100644 --- a/src/test/java/dk/camelot64/kickc/test/TestPrograms.java +++ b/src/test/java/dk/camelot64/kickc/test/TestPrograms.java @@ -46,6 +46,11 @@ public class TestPrograms { AsmFragmentTemplateUsages.logUsages(log, false, false, false, false, false, false); } + @Test + public void testMultiplexer() throws IOException, URISyntaxException { + compileAndCompare("multiplexer"); + } + @Test public void testForRangedWords() throws IOException, URISyntaxException { compileAndCompare("forrangedwords"); diff --git a/src/test/java/dk/camelot64/kickc/test/kc/multiplexer.kc b/src/test/java/dk/camelot64/kickc/test/kc/multiplexer.kc new file mode 100644 index 000000000..8130b4b80 --- /dev/null +++ b/src/test/java/dk/camelot64/kickc/test/kc/multiplexer.kc @@ -0,0 +1,83 @@ +// A flexible sprite multiplexer routine +import "print.kc" + +// The number of sprites in the multiplexer +const byte PLEX_COUNT = 10; + +// The x-positions of the multiplexer sprites ($000-$1ff) +word[PLEX_COUNT] PLEX_XPOS; + +// The y-positions of the multiplexer sprites +byte[PLEX_COUNT] PLEX_YPOS = { $ff, $12, $11, $34, $2, $81, $77, $81, $ef, $11 }; + +// The sprite pointers for the multiplexed sprites +byte[PLEX_COUNT] PLEX_PTR; + +// The address of the sprite pointers on the current screen (screen+$3e8). +byte* PLEX_SCREEN_PTR = $400+$3e8; + +// Indexes of the plex-sprites sorted by sprite y-position. Each call to plexSort() will fix the sorting if changes to the Y-positions have ruined it. +byte[PLEX_COUNT] PLEX_SORTED_IDX; + +// Set the address of the sprite pointers on the current screen (screen+$3e8) +inline void plexSetScreenPtr(byte* plexScreenPtr) { + PLEX_SCREEN_PTR = plexScreenPtr; +} + +// Initialize the multiplexer data structures +void plexInit() { + for(byte i: 0..PLEX_COUNT-1) { + PLEX_SORTED_IDX[i] = i; + } +} + +// Ensure that the indices in PLEX_SORTED_IDX is sorted based on the y-positions of the sprites +// Assumes that the positions are nearly sorted already (as each sprite just moves a bit) +// Uses an insertion sort +// 1. Moves a marker from the start to end of the array. Every time the marker moves forward all elements before the marker are sorted correctly. +// 2a. If the next element after the marker is larger that the current element +// the marker can be moved forwards (as the sorting is correct). +// 2b. If the next element after the marker is smaller than the current element: +// elements before the marker are shifted right one at a time until encountering one smaller than the current one. +// It is then inserted at the spot. Now the marker can move forward. +void plexSort() { + for(byte m: 0..PLEX_COUNT-2) { + byte nxt_idx = PLEX_SORTED_IDX[m+1]; + byte nxt_y = PLEX_YPOS[nxt_idx]; + byte cur_idx = PLEX_SORTED_IDX[m]; + if(nxt_y$400 + sta print_line_cursor+1 + lda #<$400 + sta print_char_cursor + lda #>$400 + sta print_char_cursor+1 + jsr print_plex + jsr plexSort + lda print_line_cursor + sta print_char_cursor + lda print_line_cursor+1 + sta print_char_cursor+1 + jsr print_plex + rts +} +print_plex: { + ldx #0 + b1: + lda PLEX_SORTED_IDX,x + tay + lda PLEX_YPOS,y + sta print_byte.b + jsr print_byte + lda #' ' + jsr print_char + inx + cpx #PLEX_COUNT-1+1 + bne b1 + jsr print_ln + rts +} +print_ln: { + b1: + lda print_line_cursor + clc + adc #$28 + sta print_line_cursor + bcc !+ + inc print_line_cursor+1 + !: + lda print_line_cursor+1 + cmp print_char_cursor+1 + bcc b1 + bne !+ + lda print_line_cursor + cmp print_char_cursor + bcc b1 + !: + rts +} +print_char: { + ldy #0 + sta (print_char_cursor),y + inc print_char_cursor + bne !+ + inc print_char_cursor+1 + !: + rts +} +print_byte: { + .label b = 6 + lda b + lsr + lsr + lsr + lsr + tay + lda print_hextab,y + jsr print_char + lda #$f + and b + tay + lda print_hextab,y + jsr print_char + rts +} +plexSort: { + .label nxt_idx = 7 + .label nxt_y = 8 + .label m = 6 + lda #0 + sta m + b1: + ldy m + lda PLEX_SORTED_IDX+1,y + sta nxt_idx + tay + lda PLEX_YPOS,y + sta nxt_y + ldx m + ldy PLEX_SORTED_IDX,x + cmp PLEX_YPOS,y + bcs b2 + b3: + lda PLEX_SORTED_IDX,x + sta PLEX_SORTED_IDX+1,x + dex + cpx #$ff + bne b7 + b5: + inx + lda nxt_idx + sta PLEX_SORTED_IDX,x + b2: + inc m + lda m + cmp #PLEX_COUNT-2+1 + bne b1 + rts + b7: + lda nxt_y + ldy PLEX_SORTED_IDX,x + cmp PLEX_YPOS,y + bcc b3 + jmp b5 +} +print_cls: { + .label sc = 2 + lda #<$400 + sta sc + lda #>$400 + sta sc+1 + b1: + lda #' ' + ldy #0 + sta (sc),y + inc sc + bne !+ + inc sc+1 + !: + lda sc+1 + cmp #>$400+$3e8 + bne b1 + lda sc + cmp #<$400+$3e8 + bne b1 + rts +} +plexInit: { + ldx #0 + b1: + txa + sta PLEX_SORTED_IDX,x + inx + cpx #PLEX_COUNT-1+1 + bne b1 + rts +} + print_hextab: .text "0123456789abcdef" + PLEX_YPOS: .byte $ff, $12, $11, $34, 2, $81, $77, $81, $ef, $11 + PLEX_SORTED_IDX: .fill PLEX_COUNT, 0 diff --git a/src/test/java/dk/camelot64/kickc/test/ref/multiplexer.cfg b/src/test/java/dk/camelot64/kickc/test/ref/multiplexer.cfg new file mode 100644 index 000000000..6073abe02 --- /dev/null +++ b/src/test/java/dk/camelot64/kickc/test/ref/multiplexer.cfg @@ -0,0 +1,147 @@ +@begin: scope:[] from + [0] phi() [ ] ( ) + to:@19 +@19: scope:[] from @begin + [1] phi() [ ] ( ) + [2] call main [ ] ( ) + to:@end +@end: scope:[] from @19 + [3] phi() [ ] ( ) +main: scope:[main] from @19 + [4] phi() [ ] ( main:2 [ ] ) + [5] call plexInit [ ] ( main:2 [ ] ) + to:main::@1 +main::@1: scope:[main] from main + [6] phi() [ ] ( main:2 [ ] ) + [7] call print_cls [ ] ( main:2 [ ] ) + to:main::@2 +main::@2: scope:[main] from main::@1 + [8] phi() [ ] ( main:2 [ ] ) + [9] call print_plex [ print_line_cursor#1 ] ( main:2 [ print_line_cursor#1 ] ) + to:main::@3 +main::@3: scope:[main] from main::@2 + [10] phi() [ print_line_cursor#1 ] ( main:2 [ print_line_cursor#1 ] ) + [11] call plexSort [ print_line_cursor#1 ] ( main:2 [ print_line_cursor#1 ] ) + to:main::@4 +main::@4: scope:[main] from main::@3 + [12] (byte*~) print_char_cursor#47 ← (byte*) print_line_cursor#1 [ print_char_cursor#47 print_line_cursor#1 ] ( main:2 [ print_char_cursor#47 print_line_cursor#1 ] ) + [13] call print_plex [ ] ( main:2 [ ] ) + to:main::@return +main::@return: scope:[main] from main::@4 + [14] return [ ] ( main:2 [ ] ) + to:@return +print_plex: scope:[print_plex] from main::@2 main::@4 + [15] (byte*) print_line_cursor#34 ← phi( main::@2/((byte*))(word/signed word/dword/signed dword) 1024 main::@4/(byte*) print_line_cursor#1 ) [ print_char_cursor#44 print_line_cursor#34 ] ( main:2::print_plex:9 [ print_char_cursor#44 print_line_cursor#34 ] main:2::print_plex:13 [ print_char_cursor#44 print_line_cursor#34 ] ) + [15] (byte*) print_char_cursor#44 ← phi( main::@2/((byte*))(word/signed word/dword/signed dword) 1024 main::@4/(byte*~) print_char_cursor#47 ) [ print_char_cursor#44 print_line_cursor#34 ] ( main:2::print_plex:9 [ print_char_cursor#44 print_line_cursor#34 ] main:2::print_plex:13 [ print_char_cursor#44 print_line_cursor#34 ] ) + to:print_plex::@1 +print_plex::@1: scope:[print_plex] from print_plex print_plex::@4 + [16] (byte*) print_char_cursor#40 ← phi( print_plex/(byte*) print_char_cursor#44 print_plex::@4/(byte*) print_char_cursor#25 ) [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 ] ) + [16] (byte) print_plex::i#2 ← phi( print_plex/(byte/signed byte/word/signed word/dword/signed dword) 0 print_plex::@4/(byte) print_plex::i#1 ) [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 ] ) + [17] (byte) print_byte::b#0 ← *((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) print_plex::i#2)) [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 ] ) + [18] call print_byte [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + to:print_plex::@3 +print_plex::@3: scope:[print_plex] from print_plex::@1 + [19] phi() [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + [20] call print_char [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + to:print_plex::@4 +print_plex::@4: scope:[print_plex] from print_plex::@3 + [21] (byte) print_plex::i#1 ← ++ (byte) print_plex::i#2 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] ) + [22] if((byte) print_plex::i#1!=(const byte) PLEX_COUNT#0-(byte/signed byte/word/signed word/dword/signed dword) 1+(byte/signed byte/word/signed word/dword/signed dword) 1) goto print_plex::@1 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] ) + to:print_plex::@2 +print_plex::@2: scope:[print_plex] from print_plex::@4 + [23] phi() [ print_line_cursor#34 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_char_cursor#25 ] ) + [24] call print_ln [ print_line_cursor#1 ] ( main:2::print_plex:9 [ print_line_cursor#1 ] main:2::print_plex:13 [ print_line_cursor#1 ] ) + to:print_plex::@return +print_plex::@return: scope:[print_plex] from print_plex::@2 + [25] return [ print_line_cursor#1 ] ( main:2::print_plex:9 [ print_line_cursor#1 ] main:2::print_plex:13 [ print_line_cursor#1 ] ) + to:@return +print_ln: scope:[print_ln] from print_plex::@2 + [26] phi() [ print_line_cursor#34 print_char_cursor#25 ] ( main:2::print_plex:9::print_ln:24 [ print_line_cursor#34 print_char_cursor#25 ] main:2::print_plex:13::print_ln:24 [ print_line_cursor#34 print_char_cursor#25 ] ) + to:print_ln::@1 +print_ln::@1: scope:[print_ln] from print_ln print_ln::@1 + [27] (byte*) print_line_cursor#12 ← phi( print_ln/(byte*) print_line_cursor#34 print_ln::@1/(byte*) print_line_cursor#1 ) [ print_char_cursor#25 print_line_cursor#12 ] ( main:2::print_plex:9::print_ln:24 [ print_char_cursor#25 print_line_cursor#12 ] main:2::print_plex:13::print_ln:24 [ print_char_cursor#25 print_line_cursor#12 ] ) + [28] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#12 + (byte/signed byte/word/signed word/dword/signed dword) 40 [ print_line_cursor#1 print_char_cursor#25 ] ( main:2::print_plex:9::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] main:2::print_plex:13::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] ) + [29] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#25) goto print_ln::@1 [ print_line_cursor#1 print_char_cursor#25 ] ( main:2::print_plex:9::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] main:2::print_plex:13::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] ) + to:print_ln::@return +print_ln::@return: scope:[print_ln] from print_ln::@1 + [30] return [ print_line_cursor#1 ] ( main:2::print_plex:9::print_ln:24 [ print_line_cursor#1 ] main:2::print_plex:13::print_ln:24 [ print_line_cursor#1 ] ) + to:@return +print_char: scope:[print_char] from print_byte print_byte::@1 print_plex::@3 + [31] (byte*) print_char_cursor#24 ← phi( print_byte/(byte*) print_char_cursor#40 print_byte::@1/(byte*) print_char_cursor#25 print_plex::@3/(byte*) print_char_cursor#25 ) [ print_char::ch#3 print_char_cursor#24 ] ( main:2::print_plex:9::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char::ch#3 print_char_cursor#24 ] main:2::print_plex:13::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char::ch#3 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char::ch#3 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char::ch#3 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char::ch#3 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char::ch#3 print_char_cursor#24 ] ) + [31] (byte) print_char::ch#3 ← phi( print_byte/(byte) print_char::ch#0 print_byte::@1/(byte) print_char::ch#1 print_plex::@3/(byte) ' ' ) [ print_char::ch#3 print_char_cursor#24 ] ( main:2::print_plex:9::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char::ch#3 print_char_cursor#24 ] main:2::print_plex:13::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char::ch#3 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char::ch#3 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char::ch#3 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char::ch#3 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char::ch#3 print_char_cursor#24 ] ) + [32] *((byte*) print_char_cursor#24) ← (byte) print_char::ch#3 [ print_char_cursor#24 ] ( main:2::print_plex:9::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] main:2::print_plex:13::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] ) + [33] (byte*) print_char_cursor#25 ← ++ (byte*) print_char_cursor#24 [ print_char_cursor#25 ] ( main:2::print_plex:9::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:9::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#25 ] main:2::print_plex:9::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + to:print_char::@return +print_char::@return: scope:[print_char] from print_char + [34] return [ print_char_cursor#25 ] ( main:2::print_plex:9::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:9::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#25 ] main:2::print_plex:9::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + to:@return +print_byte: scope:[print_byte] from print_plex::@1 + [35] (byte~) print_byte::$0 ← (byte) print_byte::b#0 >> (byte/signed byte/word/signed word/dword/signed dword) 4 [ print_char_cursor#40 print_byte::b#0 print_byte::$0 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_byte::$0 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_byte::$0 ] ) + [36] (byte) print_char::ch#0 ← *((const byte[]) print_hextab#0 + (byte~) print_byte::$0) [ print_char_cursor#40 print_byte::b#0 print_char::ch#0 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_char::ch#0 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_char::ch#0 ] ) + [37] call print_char [ print_char_cursor#25 print_byte::b#0 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::b#0 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::b#0 ] ) + to:print_byte::@1 +print_byte::@1: scope:[print_byte] from print_byte + [38] (byte~) print_byte::$2 ← (byte) print_byte::b#0 & (byte/signed byte/word/signed word/dword/signed dword) 15 [ print_char_cursor#25 print_byte::$2 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::$2 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::$2 ] ) + [39] (byte) print_char::ch#1 ← *((const byte[]) print_hextab#0 + (byte~) print_byte::$2) [ print_char_cursor#25 print_char::ch#1 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_char::ch#1 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_char::ch#1 ] ) + [40] call print_char [ print_char_cursor#25 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + to:print_byte::@return +print_byte::@return: scope:[print_byte] from print_byte::@1 + [41] return [ print_char_cursor#25 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + to:@return +plexSort: scope:[plexSort] from main::@3 + [42] phi() [ ] ( main:2::plexSort:11 [ print_line_cursor#1 ] ) + to:plexSort::@1 +plexSort::@1: scope:[plexSort] from plexSort plexSort::@2 + [43] (byte) plexSort::m#2 ← phi( plexSort/(byte/signed byte/word/signed word/dword/signed dword) 0 plexSort::@2/(byte) plexSort::m#1 ) [ plexSort::m#2 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 ] ) + [44] (byte) plexSort::nxt_idx#0 ← *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0+(byte/signed byte/word/signed word/dword/signed dword) 1 + (byte) plexSort::m#2) [ plexSort::m#2 plexSort::nxt_idx#0 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 ] ) + [45] (byte) plexSort::nxt_y#0 ← *((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + (byte) plexSort::nxt_idx#0) [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ) + [46] (byte) plexSort::cur_idx#0 ← *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::m#2) [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::cur_idx#0 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::cur_idx#0 ] ) + [47] if((byte) plexSort::nxt_y#0>=*((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + (byte) plexSort::cur_idx#0)) goto plexSort::@2 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ) + to:plexSort::@10 +plexSort::@10: scope:[plexSort] from plexSort::@1 + [48] (byte~) plexSort::s#6 ← (byte) plexSort::m#2 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#6 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#6 ] ) + to:plexSort::@3 +plexSort::@3: scope:[plexSort] from plexSort::@10 plexSort::@7 + [49] (byte) plexSort::s#3 ← phi( plexSort::@7/(byte) plexSort::s#1 plexSort::@10/(byte~) plexSort::s#6 ) [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#3 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#3 ] ) + [50] *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0+(byte/signed byte/word/signed word/dword/signed dword) 1 + (byte) plexSort::s#3) ← *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#3) [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#3 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#3 ] ) + [51] (byte) plexSort::s#1 ← -- (byte) plexSort::s#3 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ) + [52] if((byte) plexSort::s#1!=(byte/word/signed word/dword/signed dword) 255) goto plexSort::@7 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ) + to:plexSort::@5 +plexSort::@5: scope:[plexSort] from plexSort::@3 plexSort::@7 + [53] (byte) plexSort::s#2 ← ++ (byte) plexSort::s#1 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::s#2 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::s#2 ] ) + [54] *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#2) ← (byte) plexSort::nxt_idx#0 [ plexSort::m#2 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 ] ) + to:plexSort::@2 +plexSort::@2: scope:[plexSort] from plexSort::@1 plexSort::@5 + [55] (byte) plexSort::m#1 ← ++ (byte) plexSort::m#2 [ plexSort::m#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#1 ] ) + [56] if((byte) plexSort::m#1!=(const byte) PLEX_COUNT#0-(byte/signed byte/word/signed word/dword/signed dword) 2+(byte/signed byte/word/signed word/dword/signed dword) 1) goto plexSort::@1 [ plexSort::m#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#1 ] ) + to:plexSort::@return +plexSort::@return: scope:[plexSort] from plexSort::@2 + [57] return [ ] ( main:2::plexSort:11 [ print_line_cursor#1 ] ) + to:@return +plexSort::@7: scope:[plexSort] from plexSort::@3 + [58] if((byte) plexSort::nxt_y#0<*((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#1))) goto plexSort::@3 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ) + to:plexSort::@5 +print_cls: scope:[print_cls] from main::@1 + [59] phi() [ ] ( main:2::print_cls:7 [ ] ) + to:print_cls::@1 +print_cls::@1: scope:[print_cls] from print_cls print_cls::@1 + [60] (byte*) print_cls::sc#2 ← phi( print_cls/((byte*))(word/signed word/dword/signed dword) 1024 print_cls::@1/(byte*) print_cls::sc#1 ) [ print_cls::sc#2 ] ( main:2::print_cls:7 [ print_cls::sc#2 ] ) + [61] *((byte*) print_cls::sc#2) ← (byte) ' ' [ print_cls::sc#2 ] ( main:2::print_cls:7 [ print_cls::sc#2 ] ) + [62] (byte*) print_cls::sc#1 ← ++ (byte*) print_cls::sc#2 [ print_cls::sc#1 ] ( main:2::print_cls:7 [ print_cls::sc#1 ] ) + [63] if((byte*) print_cls::sc#1!=((byte*))(word/signed word/dword/signed dword) 1024+(word/signed word/dword/signed dword) 1000) goto print_cls::@1 [ print_cls::sc#1 ] ( main:2::print_cls:7 [ print_cls::sc#1 ] ) + to:print_cls::@return +print_cls::@return: scope:[print_cls] from print_cls::@1 + [64] return [ ] ( main:2::print_cls:7 [ ] ) + to:@return +plexInit: scope:[plexInit] from main + [65] phi() [ ] ( main:2::plexInit:5 [ ] ) + to:plexInit::@1 +plexInit::@1: scope:[plexInit] from plexInit plexInit::@1 + [66] (byte) plexInit::i#2 ← phi( plexInit/(byte/signed byte/word/signed word/dword/signed dword) 0 plexInit::@1/(byte) plexInit::i#1 ) [ plexInit::i#2 ] ( main:2::plexInit:5 [ plexInit::i#2 ] ) + [67] *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexInit::i#2) ← (byte) plexInit::i#2 [ plexInit::i#2 ] ( main:2::plexInit:5 [ plexInit::i#2 ] ) + [68] (byte) plexInit::i#1 ← ++ (byte) plexInit::i#2 [ plexInit::i#1 ] ( main:2::plexInit:5 [ plexInit::i#1 ] ) + [69] if((byte) plexInit::i#1!=(const byte) PLEX_COUNT#0-(byte/signed byte/word/signed word/dword/signed dword) 1+(byte/signed byte/word/signed word/dword/signed dword) 1) goto plexInit::@1 [ plexInit::i#1 ] ( main:2::plexInit:5 [ plexInit::i#1 ] ) + to:plexInit::@return +plexInit::@return: scope:[plexInit] from plexInit::@1 + [70] return [ ] ( main:2::plexInit:5 [ ] ) + to:@return diff --git a/src/test/java/dk/camelot64/kickc/test/ref/multiplexer.log b/src/test/java/dk/camelot64/kickc/test/ref/multiplexer.log new file mode 100644 index 000000000..3bfeee3e0 --- /dev/null +++ b/src/test/java/dk/camelot64/kickc/test/ref/multiplexer.log @@ -0,0 +1,3359 @@ +PARSING src/test/java/dk/camelot64/kickc/test/kc/multiplexer.kc +// A flexible sprite multiplexer routine +import "print.kc" + +// The number of sprites in the multiplexer +const byte PLEX_COUNT = 10; + +// The x-positions of the multiplexer sprites ($000-$1ff) +word[PLEX_COUNT] PLEX_XPOS; + +// The y-positions of the multiplexer sprites +byte[PLEX_COUNT] PLEX_YPOS = { $ff, $12, $11, $34, $2, $81, $77, $81, $ef, $11 }; + +// The sprite pointers for the multiplexed sprites +byte[PLEX_COUNT] PLEX_PTR; + +// The address of the sprite pointers on the current screen (screen+$3e8). +byte* PLEX_SCREEN_PTR = $400+$3e8; + +// Indexes of the plex-sprites sorted by sprite y-position. Each call to plexSort() will fix the sorting if changes to the Y-positions have ruined it. +byte[PLEX_COUNT] PLEX_SORTED_IDX; + +// Set the address of the sprite pointers on the current screen (screen+$3e8) +inline void plexSetScreenPtr(byte* plexScreenPtr) { + PLEX_SCREEN_PTR = plexScreenPtr; +} + +// Initialize the multiplexer data structures +void plexInit() { + for(byte i: 0..PLEX_COUNT-1) { + PLEX_SORTED_IDX[i] = i; + } +} + +// Ensure that the indices in PLEX_SORTED_IDX is sorted based on the y-positions of the sprites +// Assumes that the positions are nearly sorted already (as each sprite just moves a bit) +// Uses an insertion sort +// 1. Moves a marker from the start to end of the array. Every time the marker moves forward all elements before the marker are sorted correctly. +// 2a. If the next element after the marker is larger that the current element +// the marker can be moved forwards (as the sorting is correct). +// 2b. If the next element after the marker is smaller than the current element: +// elements before the marker are shifted right one at a time until encountering one smaller than the current one. +// It is then inserted at the spot. Now the marker can move forward. +void plexSort() { + for(byte m: 0..PLEX_COUNT-2) { + byte nxt_idx = PLEX_SORTED_IDX[m+1]; + byte nxt_y = PLEX_YPOS[nxt_idx]; + byte cur_idx = PLEX_SORTED_IDX[m]; + if(nxt_yw); + print_byte(dw); + print_word(>4]); + print_char(print_hextab[b&$f]); +} + +// Print a single char +void print_char(byte ch) { + *(print_char_cursor++) = ch; +} + +// Clear the screen. Also resets current line/char cursor. +void print_cls() { + for(byte* sc=print_screen; sc!=print_screen+1000; sc++) { + *sc = ' '; + } + print_line_cursor = print_screen; + print_char_cursor = print_line_cursor; +} + +// Set the screen to print on. Also resets current line/char cursor. +void print_set_screen(byte* screen) { + print_screen = screen; + print_line_cursor = print_screen; + print_char_cursor = print_line_cursor; +} + +Adding pre/post-modifier (byte*) print_str_lines::str ← ++ (byte*) print_str_lines::str +Adding pre/post-modifier (byte*) print_char_cursor ← ++ (byte*) print_char_cursor +Adding pre/post-modifier (byte*) print_char_cursor ← ++ (byte*) print_char_cursor +Adding pre/post-modifier (byte*) print_str::str ← ++ (byte*) print_str::str +Adding pre/post-modifier (byte*) print_str_at::at ← ++ (byte*) print_str_at::at +Adding pre/post-modifier (byte*) print_str_at::str ← ++ (byte*) print_str_at::str +Adding pre/post-modifier (byte*) print_char_cursor ← ++ (byte*) print_char_cursor +Adding pre/post-modifier (byte*) print_cls::sc ← ++ (byte*) print_cls::sc +Adding pre/post-modifier (byte) plexSort::s ← -- (byte) plexSort::s +Adding pre/post-modifier (byte) plexSort::s ← ++ (byte) plexSort::s +SYMBOLS +(word/signed word/dword/signed dword~) $0 +(label) @1 +(label) @10 +(label) @11 +(label) @12 +(label) @13 +(label) @14 +(label) @15 +(label) @16 +(label) @17 +(label) @18 +(label) @19 +(label) @2 +(label) @3 +(label) @4 +(label) @5 +(label) @6 +(label) @7 +(label) @8 +(label) @9 +(label) @begin +(label) @end +(byte) PLEX_COUNT +(byte[PLEX_COUNT]) PLEX_PTR +(byte*) PLEX_SCREEN_PTR +(byte[PLEX_COUNT]) PLEX_SORTED_IDX +(word[PLEX_COUNT]) PLEX_XPOS +(byte[PLEX_COUNT]) PLEX_YPOS +(void()) main() +(void~) main::$0 +(void~) main::$1 +(void~) main::$2 +(void~) main::$3 +(void~) main::$4 +(label) main::@return +(void()) plexInit() +(byte/signed word/word/dword/signed dword~) plexInit::$0 +(bool~) plexInit::$1 +(label) plexInit::@1 +(label) plexInit::@2 +(label) plexInit::@return +(byte) plexInit::i +inline (void()) plexSetScreenPtr((byte*) plexSetScreenPtr::plexScreenPtr) +(label) plexSetScreenPtr::@return +(byte*) plexSetScreenPtr::plexScreenPtr +(void()) plexSort() +(byte/signed word/word/dword/signed dword~) plexSort::$0 +(byte/signed word/word/dword/signed dword~) plexSort::$1 +(bool~) plexSort::$2 +(bool~) plexSort::$3 +(byte/signed word/word/dword/signed dword~) plexSort::$4 +(bool~) plexSort::$5 +(bool~) plexSort::$6 +(bool~) plexSort::$7 +(bool~) plexSort::$8 +(label) plexSort::@1 +(label) plexSort::@2 +(label) plexSort::@3 +(label) plexSort::@4 +(label) plexSort::@5 +(label) plexSort::@6 +(label) plexSort::@return +(byte) plexSort::cur_idx +(byte) plexSort::m +(byte) plexSort::nxt_idx +(byte) plexSort::nxt_y +(byte) plexSort::s +(void()) print_byte((byte) print_byte::b) +(byte~) print_byte::$0 +(void~) print_byte::$1 +(byte~) print_byte::$2 +(void~) print_byte::$3 +(label) print_byte::@return +(byte) print_byte::b +(void()) print_char((byte) print_char::ch) +(label) print_char::@return +(byte) print_char::ch +(byte*) print_char_cursor +(void()) print_cls() +(byte*~) print_cls::$0 +(bool~) print_cls::$1 +(label) print_cls::@1 +(label) print_cls::@2 +(label) print_cls::@return +(byte*) print_cls::sc +(void()) print_dword((dword) print_dword::dw) +(word~) print_dword::$0 +(void~) print_dword::$1 +(word~) print_dword::$2 +(void~) print_dword::$3 +(label) print_dword::@return +(dword) print_dword::dw +(byte[]) print_hextab +(byte*) print_line_cursor +(void()) print_ln() +(byte*~) print_ln::$0 +(bool~) print_ln::$1 +(label) print_ln::@1 +(label) print_ln::@2 +(label) print_ln::@return +(void()) print_plex() +(byte/signed word/word/dword/signed dword~) print_plex::$0 +(void~) print_plex::$1 +(void~) print_plex::$2 +(bool~) print_plex::$3 +(void~) print_plex::$4 +(label) print_plex::@1 +(label) print_plex::@2 +(label) print_plex::@return +(byte) print_plex::i +(void()) print_sbyte((signed byte) print_sbyte::b) +(bool~) print_sbyte::$0 +(bool~) print_sbyte::$1 +(void~) print_sbyte::$2 +(signed byte~) print_sbyte::$3 +(byte~) print_sbyte::$4 +(void~) print_sbyte::$5 +(label) print_sbyte::@1 +(label) print_sbyte::@2 +(label) print_sbyte::@return +(signed byte) print_sbyte::b +(byte*) print_screen +(void()) print_sdword((signed dword) print_sdword::dw) +(bool~) print_sdword::$0 +(bool~) print_sdword::$1 +(void~) print_sdword::$2 +(signed dword~) print_sdword::$3 +(dword~) print_sdword::$4 +(void~) print_sdword::$5 +(label) print_sdword::@1 +(label) print_sdword::@2 +(label) print_sdword::@return +(signed dword) print_sdword::dw +(void()) print_set_screen((byte*) print_set_screen::screen) +(label) print_set_screen::@return +(byte*) print_set_screen::screen +(void()) print_str((byte*) print_str::str) +(bool~) print_str::$0 +(label) print_str::@1 +(label) print_str::@2 +(label) print_str::@3 +(label) print_str::@4 +(label) print_str::@5 +(label) print_str::@6 +(label) print_str::@return +(byte*) print_str::str +(void()) print_str_at((byte*) print_str_at::str , (byte*) print_str_at::at) +(bool~) print_str_at::$0 +(label) print_str_at::@1 +(label) print_str_at::@2 +(label) print_str_at::@3 +(label) print_str_at::@4 +(label) print_str_at::@5 +(label) print_str_at::@6 +(label) print_str_at::@return +(byte*) print_str_at::at +(byte*) print_str_at::str +(void()) print_str_lines((byte*) print_str_lines::str) +(bool~) print_str_lines::$0 +(bool~) print_str_lines::$1 +(bool~) print_str_lines::$2 +(bool~) print_str_lines::$3 +(void~) print_str_lines::$4 +(label) print_str_lines::@1 +(label) print_str_lines::@10 +(label) print_str_lines::@2 +(label) print_str_lines::@3 +(label) print_str_lines::@4 +(label) print_str_lines::@5 +(label) print_str_lines::@6 +(label) print_str_lines::@7 +(label) print_str_lines::@8 +(label) print_str_lines::@9 +(label) print_str_lines::@return +(byte) print_str_lines::ch +(byte*) print_str_lines::str +(void()) print_str_ln((byte*) print_str_ln::str) +(void~) print_str_ln::$0 +(void~) print_str_ln::$1 +(label) print_str_ln::@return +(byte*) print_str_ln::str +(void()) print_sword((signed word) print_sword::w) +(bool~) print_sword::$0 +(bool~) print_sword::$1 +(void~) print_sword::$2 +(signed word~) print_sword::$3 +(word~) print_sword::$4 +(void~) print_sword::$5 +(label) print_sword::@1 +(label) print_sword::@2 +(label) print_sword::@return +(signed word) print_sword::w +(void()) print_word((word) print_word::w) +(byte~) print_word::$0 +(void~) print_word::$1 +(byte~) print_word::$2 +(void~) print_word::$3 +(label) print_word::@return +(word) print_word::w + +Promoting word/signed word/dword/signed dword to byte* in print_screen ← ((byte*)) 1024 +Promoting word/signed word/dword/signed dword to byte* in PLEX_SCREEN_PTR ← ((byte*)) $0 +INITIAL CONTROL FLOW GRAPH +@begin: scope:[] from + (byte*) print_screen ← ((byte*)) (word/signed word/dword/signed dword) 1024 + (byte*) print_line_cursor ← (byte*) print_screen + (byte*) print_char_cursor ← (byte*) print_line_cursor + to:@1 +print_str_lines: scope:[print_str_lines] from + to:print_str_lines::@1 +print_str_lines::@1: scope:[print_str_lines] from print_str_lines print_str_lines::@9 + (bool~) print_str_lines::$0 ← *((byte*) print_str_lines::str) != (byte) '@' + if((bool~) print_str_lines::$0) goto print_str_lines::@2 + to:print_str_lines::@6 +print_str_lines::@2: scope:[print_str_lines] from print_str_lines::@1 print_str_lines::@7 + to:print_str_lines::@4 +print_str_lines::@6: scope:[print_str_lines] from print_str_lines::@1 + to:print_str_lines::@3 +print_str_lines::@3: scope:[print_str_lines] from print_str_lines::@10 print_str_lines::@6 + to:print_str_lines::@return +print_str_lines::@7: scope:[print_str_lines] from + to:print_str_lines::@2 +print_str_lines::@4: scope:[print_str_lines] from print_str_lines::@2 print_str_lines::@5 + (byte) print_str_lines::ch ← *((byte*) print_str_lines::str) + (byte*) print_str_lines::str ← ++ (byte*) print_str_lines::str + (bool~) print_str_lines::$1 ← (byte) print_str_lines::ch != (byte) '@' + (bool~) print_str_lines::$2 ← ! (bool~) print_str_lines::$1 + if((bool~) print_str_lines::$2) goto print_str_lines::@5 + to:print_str_lines::@8 +print_str_lines::@5: scope:[print_str_lines] from print_str_lines::@4 print_str_lines::@8 + (bool~) print_str_lines::$3 ← (byte) print_str_lines::ch != (byte) '@' + if((bool~) print_str_lines::$3) goto print_str_lines::@4 + to:print_str_lines::@9 +print_str_lines::@8: scope:[print_str_lines] from print_str_lines::@4 + *((byte*) print_char_cursor) ← (byte) print_str_lines::ch + (byte*) print_char_cursor ← ++ (byte*) print_char_cursor + to:print_str_lines::@5 +print_str_lines::@9: scope:[print_str_lines] from print_str_lines::@5 + (void~) print_str_lines::$4 ← call print_ln + to:print_str_lines::@1 +print_str_lines::@10: scope:[print_str_lines] from + to:print_str_lines::@3 +print_str_lines::@return: scope:[print_str_lines] from print_str_lines::@3 + return + to:@return +@1: scope:[] from @begin + to:@2 +print_str_ln: scope:[print_str_ln] from + (void~) print_str_ln::$0 ← call print_str (byte*) print_str_ln::str + (void~) print_str_ln::$1 ← call print_ln + to:print_str_ln::@return +print_str_ln::@return: scope:[print_str_ln] from print_str_ln + return + to:@return +@2: scope:[] from @1 + to:@3 +print_str: scope:[print_str] from + to:print_str::@1 +print_str::@1: scope:[print_str] from print_str print_str::@2 + (bool~) print_str::$0 ← *((byte*) print_str::str) != (byte) '@' + if((bool~) print_str::$0) goto print_str::@2 + to:print_str::@4 +print_str::@2: scope:[print_str] from print_str::@1 print_str::@5 + *((byte*) print_char_cursor) ← *((byte*) print_str::str) + (byte*) print_char_cursor ← ++ (byte*) print_char_cursor + (byte*) print_str::str ← ++ (byte*) print_str::str + to:print_str::@1 +print_str::@4: scope:[print_str] from print_str::@1 + to:print_str::@3 +print_str::@3: scope:[print_str] from print_str::@4 print_str::@6 + to:print_str::@return +print_str::@5: scope:[print_str] from + to:print_str::@2 +print_str::@6: scope:[print_str] from + to:print_str::@3 +print_str::@return: scope:[print_str] from print_str::@3 + return + to:@return +@3: scope:[] from @2 + to:@4 +print_str_at: scope:[print_str_at] from + to:print_str_at::@1 +print_str_at::@1: scope:[print_str_at] from print_str_at print_str_at::@2 + (bool~) print_str_at::$0 ← *((byte*) print_str_at::str) != (byte) '@' + if((bool~) print_str_at::$0) goto print_str_at::@2 + to:print_str_at::@4 +print_str_at::@2: scope:[print_str_at] from print_str_at::@1 print_str_at::@5 + *((byte*) print_str_at::at) ← *((byte*) print_str_at::str) + (byte*) print_str_at::at ← ++ (byte*) print_str_at::at + (byte*) print_str_at::str ← ++ (byte*) print_str_at::str + to:print_str_at::@1 +print_str_at::@4: scope:[print_str_at] from print_str_at::@1 + to:print_str_at::@3 +print_str_at::@3: scope:[print_str_at] from print_str_at::@4 print_str_at::@6 + to:print_str_at::@return +print_str_at::@5: scope:[print_str_at] from + to:print_str_at::@2 +print_str_at::@6: scope:[print_str_at] from + to:print_str_at::@3 +print_str_at::@return: scope:[print_str_at] from print_str_at::@3 + return + to:@return +@4: scope:[] from @3 + to:@5 +print_ln: scope:[print_ln] from + to:print_ln::@1 +print_ln::@1: scope:[print_ln] from print_ln print_ln::@1 + (byte*~) print_ln::$0 ← (byte*) print_line_cursor + (byte/signed byte/word/signed word/dword/signed dword) 40 + (byte*) print_line_cursor ← (byte*~) print_ln::$0 + (bool~) print_ln::$1 ← (byte*) print_line_cursor < (byte*) print_char_cursor + if((bool~) print_ln::$1) goto print_ln::@1 + to:print_ln::@2 +print_ln::@2: scope:[print_ln] from print_ln::@1 + (byte*) print_char_cursor ← (byte*) print_line_cursor + to:print_ln::@return +print_ln::@return: scope:[print_ln] from print_ln::@2 + return + to:@return +@5: scope:[] from @4 + to:@6 +print_sword: scope:[print_sword] from + (bool~) print_sword::$0 ← (signed word) print_sword::w < (byte/signed byte/word/signed word/dword/signed dword) 0 + (bool~) print_sword::$1 ← ! (bool~) print_sword::$0 + if((bool~) print_sword::$1) goto print_sword::@1 + to:print_sword::@2 +print_sword::@1: scope:[print_sword] from print_sword print_sword::@2 + (word~) print_sword::$4 ← ((word)) (signed word) print_sword::w + (void~) print_sword::$5 ← call print_word (word~) print_sword::$4 + to:print_sword::@return +print_sword::@2: scope:[print_sword] from print_sword + (void~) print_sword::$2 ← call print_char (byte) '-' + (signed word~) print_sword::$3 ← - (signed word) print_sword::w + (signed word) print_sword::w ← (signed word~) print_sword::$3 + to:print_sword::@1 +print_sword::@return: scope:[print_sword] from print_sword::@1 + return + to:@return +@6: scope:[] from @5 + to:@7 +print_sbyte: scope:[print_sbyte] from + (bool~) print_sbyte::$0 ← (signed byte) print_sbyte::b < (byte/signed byte/word/signed word/dword/signed dword) 0 + (bool~) print_sbyte::$1 ← ! (bool~) print_sbyte::$0 + if((bool~) print_sbyte::$1) goto print_sbyte::@1 + to:print_sbyte::@2 +print_sbyte::@1: scope:[print_sbyte] from print_sbyte print_sbyte::@2 + (byte~) print_sbyte::$4 ← ((byte)) (signed byte) print_sbyte::b + (void~) print_sbyte::$5 ← call print_byte (byte~) print_sbyte::$4 + to:print_sbyte::@return +print_sbyte::@2: scope:[print_sbyte] from print_sbyte + (void~) print_sbyte::$2 ← call print_char (byte) '-' + (signed byte~) print_sbyte::$3 ← - (signed byte) print_sbyte::b + (signed byte) print_sbyte::b ← (signed byte~) print_sbyte::$3 + to:print_sbyte::@1 +print_sbyte::@return: scope:[print_sbyte] from print_sbyte::@1 + return + to:@return +@7: scope:[] from @6 + to:@8 +print_word: scope:[print_word] from + (byte~) print_word::$0 ← > (word) print_word::w + (void~) print_word::$1 ← call print_byte (byte~) print_word::$0 + (byte~) print_word::$2 ← < (word) print_word::w + (void~) print_word::$3 ← call print_byte (byte~) print_word::$2 + to:print_word::@return +print_word::@return: scope:[print_word] from print_word + return + to:@return +@8: scope:[] from @7 + to:@9 +print_dword: scope:[print_dword] from + (word~) print_dword::$0 ← > (dword) print_dword::dw + (void~) print_dword::$1 ← call print_word (word~) print_dword::$0 + (word~) print_dword::$2 ← < (dword) print_dword::dw + (void~) print_dword::$3 ← call print_word (word~) print_dword::$2 + to:print_dword::@return +print_dword::@return: scope:[print_dword] from print_dword + return + to:@return +@9: scope:[] from @8 + to:@10 +print_sdword: scope:[print_sdword] from + (bool~) print_sdword::$0 ← (signed dword) print_sdword::dw < (byte/signed byte/word/signed word/dword/signed dword) 0 + (bool~) print_sdword::$1 ← ! (bool~) print_sdword::$0 + if((bool~) print_sdword::$1) goto print_sdword::@1 + to:print_sdword::@2 +print_sdword::@1: scope:[print_sdword] from print_sdword print_sdword::@2 + (dword~) print_sdword::$4 ← ((dword)) (signed dword) print_sdword::dw + (void~) print_sdword::$5 ← call print_dword (dword~) print_sdword::$4 + to:print_sdword::@return +print_sdword::@2: scope:[print_sdword] from print_sdword + (void~) print_sdword::$2 ← call print_char (byte) '-' + (signed dword~) print_sdword::$3 ← - (signed dword) print_sdword::dw + (signed dword) print_sdword::dw ← (signed dword~) print_sdword::$3 + to:print_sdword::@1 +print_sdword::@return: scope:[print_sdword] from print_sdword::@1 + return + to:@return +@10: scope:[] from @9 + (byte[]) print_hextab ← (string) "0123456789abcdef" + to:@11 +print_byte: scope:[print_byte] from + (byte~) print_byte::$0 ← (byte) print_byte::b >> (byte/signed byte/word/signed word/dword/signed dword) 4 + (void~) print_byte::$1 ← call print_char *((byte[]) print_hextab + (byte~) print_byte::$0) + (byte~) print_byte::$2 ← (byte) print_byte::b & (byte/signed byte/word/signed word/dword/signed dword) 15 + (void~) print_byte::$3 ← call print_char *((byte[]) print_hextab + (byte~) print_byte::$2) + to:print_byte::@return +print_byte::@return: scope:[print_byte] from print_byte + return + to:@return +@11: scope:[] from @10 + to:@12 +print_char: scope:[print_char] from + *((byte*) print_char_cursor) ← (byte) print_char::ch + (byte*) print_char_cursor ← ++ (byte*) print_char_cursor + to:print_char::@return +print_char::@return: scope:[print_char] from print_char + return + to:@return +@12: scope:[] from @11 + to:@13 +print_cls: scope:[print_cls] from + (byte*) print_cls::sc ← (byte*) print_screen + to:print_cls::@1 +print_cls::@1: scope:[print_cls] from print_cls print_cls::@1 + *((byte*) print_cls::sc) ← (byte) ' ' + (byte*) print_cls::sc ← ++ (byte*) print_cls::sc + (byte*~) print_cls::$0 ← (byte*) print_screen + (word/signed word/dword/signed dword) 1000 + (bool~) print_cls::$1 ← (byte*) print_cls::sc != (byte*~) print_cls::$0 + if((bool~) print_cls::$1) goto print_cls::@1 + to:print_cls::@2 +print_cls::@2: scope:[print_cls] from print_cls::@1 + (byte*) print_line_cursor ← (byte*) print_screen + (byte*) print_char_cursor ← (byte*) print_line_cursor + to:print_cls::@return +print_cls::@return: scope:[print_cls] from print_cls::@2 + return + to:@return +@13: scope:[] from @12 + to:@14 +print_set_screen: scope:[print_set_screen] from + (byte*) print_screen ← (byte*) print_set_screen::screen + (byte*) print_line_cursor ← (byte*) print_screen + (byte*) print_char_cursor ← (byte*) print_line_cursor + to:print_set_screen::@return +print_set_screen::@return: scope:[print_set_screen] from print_set_screen + return + to:@return +@14: scope:[] from @13 + (byte) PLEX_COUNT ← (byte/signed byte/word/signed word/dword/signed dword) 10 + (word[PLEX_COUNT]) PLEX_XPOS ← { fill( PLEX_COUNT, 0) } + (byte[PLEX_COUNT]) PLEX_YPOS ← { (byte/word/signed word/dword/signed dword) 255, (byte/signed byte/word/signed word/dword/signed dword) 18, (byte/signed byte/word/signed word/dword/signed dword) 17, (byte/signed byte/word/signed word/dword/signed dword) 52, (byte/signed byte/word/signed word/dword/signed dword) 2, (byte/word/signed word/dword/signed dword) 129, (byte/signed byte/word/signed word/dword/signed dword) 119, (byte/word/signed word/dword/signed dword) 129, (byte/word/signed word/dword/signed dword) 239, (byte/signed byte/word/signed word/dword/signed dword) 17 } + (byte[PLEX_COUNT]) PLEX_PTR ← { fill( PLEX_COUNT, 0) } + (word/signed word/dword/signed dword~) $0 ← (word/signed word/dword/signed dword) 1024 + (word/signed word/dword/signed dword) 1000 + (byte*) PLEX_SCREEN_PTR ← ((byte*)) (word/signed word/dword/signed dword~) $0 + (byte[PLEX_COUNT]) PLEX_SORTED_IDX ← { fill( PLEX_COUNT, 0) } + to:@15 +plexSetScreenPtr: scope:[plexSetScreenPtr] from + (byte*) PLEX_SCREEN_PTR ← (byte*) plexSetScreenPtr::plexScreenPtr + to:plexSetScreenPtr::@return +plexSetScreenPtr::@return: scope:[plexSetScreenPtr] from plexSetScreenPtr + return + to:@return +@15: scope:[] from @14 + to:@16 +plexInit: scope:[plexInit] from + (byte/signed word/word/dword/signed dword~) plexInit::$0 ← (byte) PLEX_COUNT - (byte/signed byte/word/signed word/dword/signed dword) 1 + (byte) plexInit::i ← (byte/signed byte/word/signed word/dword/signed dword) 0 + to:plexInit::@1 +plexInit::@1: scope:[plexInit] from plexInit plexInit::@1 + *((byte[PLEX_COUNT]) PLEX_SORTED_IDX + (byte) plexInit::i) ← (byte) plexInit::i + (byte) plexInit::i ← (byte) plexInit::i + rangenext(0,plexInit::$0) + (bool~) plexInit::$1 ← (byte) plexInit::i != rangelast(0,plexInit::$0) + if((bool~) plexInit::$1) goto plexInit::@1 + to:plexInit::@2 +plexInit::@2: scope:[plexInit] from plexInit::@1 + to:plexInit::@return +plexInit::@return: scope:[plexInit] from plexInit::@2 + return + to:@return +@16: scope:[] from @15 + to:@17 +plexSort: scope:[plexSort] from + (byte/signed word/word/dword/signed dword~) plexSort::$0 ← (byte) PLEX_COUNT - (byte/signed byte/word/signed word/dword/signed dword) 2 + (byte) plexSort::m ← (byte/signed byte/word/signed word/dword/signed dword) 0 + to:plexSort::@1 +plexSort::@1: scope:[plexSort] from plexSort plexSort::@2 + (byte/signed word/word/dword/signed dword~) plexSort::$1 ← (byte) plexSort::m + (byte/signed byte/word/signed word/dword/signed dword) 1 + (byte) plexSort::nxt_idx ← *((byte[PLEX_COUNT]) PLEX_SORTED_IDX + (byte/signed word/word/dword/signed dword~) plexSort::$1) + (byte) plexSort::nxt_y ← *((byte[PLEX_COUNT]) PLEX_YPOS + (byte) plexSort::nxt_idx) + (byte) plexSort::cur_idx ← *((byte[PLEX_COUNT]) PLEX_SORTED_IDX + (byte) plexSort::m) + (bool~) plexSort::$2 ← (byte) plexSort::nxt_y < *((byte[PLEX_COUNT]) PLEX_YPOS + (byte) plexSort::cur_idx) + (bool~) plexSort::$3 ← ! (bool~) plexSort::$2 + if((bool~) plexSort::$3) goto plexSort::@2 + to:plexSort::@4 +plexSort::@2: scope:[plexSort] from plexSort::@1 plexSort::@5 + (byte) plexSort::m ← (byte) plexSort::m + rangenext(0,plexSort::$0) + (bool~) plexSort::$8 ← (byte) plexSort::m != rangelast(0,plexSort::$0) + if((bool~) plexSort::$8) goto plexSort::@1 + to:plexSort::@6 +plexSort::@4: scope:[plexSort] from plexSort::@1 + (byte) plexSort::s ← (byte) plexSort::m + to:plexSort::@3 +plexSort::@3: scope:[plexSort] from plexSort::@3 plexSort::@4 + (byte/signed word/word/dword/signed dword~) plexSort::$4 ← (byte) plexSort::s + (byte/signed byte/word/signed word/dword/signed dword) 1 + *((byte[PLEX_COUNT]) PLEX_SORTED_IDX + (byte/signed word/word/dword/signed dword~) plexSort::$4) ← *((byte[PLEX_COUNT]) PLEX_SORTED_IDX + (byte) plexSort::s) + (byte) plexSort::s ← -- (byte) plexSort::s + (bool~) plexSort::$5 ← (byte) plexSort::s != (byte/word/signed word/dword/signed dword) 255 + (bool~) plexSort::$6 ← (byte) plexSort::nxt_y < *((byte[PLEX_COUNT]) PLEX_YPOS + *((byte[PLEX_COUNT]) PLEX_SORTED_IDX + (byte) plexSort::s)) + (bool~) plexSort::$7 ← (bool~) plexSort::$5 && (bool~) plexSort::$6 + if((bool~) plexSort::$7) goto plexSort::@3 + to:plexSort::@5 +plexSort::@5: scope:[plexSort] from plexSort::@3 + (byte) plexSort::s ← ++ (byte) plexSort::s + *((byte[PLEX_COUNT]) PLEX_SORTED_IDX + (byte) plexSort::s) ← (byte) plexSort::nxt_idx + to:plexSort::@2 +plexSort::@6: scope:[plexSort] from plexSort::@2 + to:plexSort::@return +plexSort::@return: scope:[plexSort] from plexSort::@6 + return + to:@return +@17: scope:[] from @16 + to:@18 +main: scope:[main] from + (void~) main::$0 ← call plexInit + (void~) main::$1 ← call print_cls + (void~) main::$2 ← call print_plex + (void~) main::$3 ← call plexSort + (void~) main::$4 ← call print_plex + to:main::@return +main::@return: scope:[main] from main + return + to:@return +@18: scope:[] from @17 + to:@19 +print_plex: scope:[print_plex] from + (byte/signed word/word/dword/signed dword~) print_plex::$0 ← (byte) PLEX_COUNT - (byte/signed byte/word/signed word/dword/signed dword) 1 + (byte) print_plex::i ← (byte/signed byte/word/signed word/dword/signed dword) 0 + to:print_plex::@1 +print_plex::@1: scope:[print_plex] from print_plex print_plex::@1 + (void~) print_plex::$1 ← call print_byte *((byte[PLEX_COUNT]) PLEX_YPOS + *((byte[PLEX_COUNT]) PLEX_SORTED_IDX + (byte) print_plex::i)) + (void~) print_plex::$2 ← call print_char (byte) ' ' + (byte) print_plex::i ← (byte) print_plex::i + rangenext(0,print_plex::$0) + (bool~) print_plex::$3 ← (byte) print_plex::i != rangelast(0,print_plex::$0) + if((bool~) print_plex::$3) goto print_plex::@1 + to:print_plex::@2 +print_plex::@2: scope:[print_plex] from print_plex::@1 + (void~) print_plex::$4 ← call print_ln + to:print_plex::@return +print_plex::@return: scope:[print_plex] from print_plex::@2 + return + to:@return +@19: scope:[] from @18 + call main + to:@end +@end: scope:[] from @19 + +Removing unused procedure print_str_lines +Removing unused procedure print_str_ln +Removing unused procedure print_str_at +Removing unused procedure print_sword +Removing unused procedure print_sbyte +Removing unused procedure print_sdword +Removing unused procedure print_set_screen +Removing unused procedure plexSetScreenPtr +Removing unused procedure print_str +Removing unused procedure print_dword +Removing unused procedure print_word +Eliminating unused variable - keeping the call (void~) print_byte::$1 +Eliminating unused variable - keeping the call (void~) print_byte::$3 +Eliminating unused variable (word[PLEX_COUNT]) PLEX_XPOS and assignment [28] (word[PLEX_COUNT]) PLEX_XPOS ← { fill( PLEX_COUNT, 0) } +Eliminating unused variable (byte[PLEX_COUNT]) PLEX_PTR and assignment [30] (byte[PLEX_COUNT]) PLEX_PTR ← { fill( PLEX_COUNT, 0) } +Eliminating unused variable (byte*) PLEX_SCREEN_PTR and assignment [32] (byte*) PLEX_SCREEN_PTR ← ((byte*)) (word/signed word/dword/signed dword~) $0 +Eliminating unused variable - keeping the call (void~) main::$0 +Eliminating unused variable - keeping the call (void~) main::$1 +Eliminating unused variable - keeping the call (void~) main::$2 +Eliminating unused variable - keeping the call (void~) main::$3 +Eliminating unused variable - keeping the call (void~) main::$4 +Eliminating unused variable - keeping the call (void~) print_plex::$1 +Eliminating unused variable - keeping the call (void~) print_plex::$2 +Eliminating unused variable - keeping the call (void~) print_plex::$4 +Eliminating unused variable (word/signed word/dword/signed dword~) $0 and assignment [29] (word/signed word/dword/signed dword~) $0 ← (word/signed word/dword/signed dword) 1024 + (word/signed word/dword/signed dword) 1000 +Creating constant string variable for inline (const string) $1 "0123456789abcdef" +Removing empty block @1 +Removing empty block @2 +Removing empty block @3 +Removing empty block @4 +Removing empty block @5 +Removing empty block @6 +Removing empty block @7 +Removing empty block @8 +Removing empty block @9 +Removing empty block @11 +Removing empty block @12 +Removing empty block @13 +Removing empty block @15 +Removing empty block plexInit::@2 +Removing empty block @16 +Removing empty block plexSort::@6 +Removing empty block @17 +Removing empty block @18 +PROCEDURE MODIFY VARIABLE ANALYSIS +print_ln modifies print_line_cursor +print_ln modifies print_char_cursor +print_byte modifies print_char_cursor +print_char modifies print_char_cursor +print_cls modifies print_line_cursor +print_cls modifies print_char_cursor +main modifies print_line_cursor +main modifies print_char_cursor +print_plex modifies print_char_cursor +print_plex modifies print_line_cursor + +Completing Phi functions... +Completing Phi functions... +Completing Phi functions... +Completing Phi functions... +Completing Phi functions... +Completing Phi functions... + +CONTROL FLOW GRAPH SSA WITH ASSIGNMENT CALL & RETURN +@begin: scope:[] from + (byte*) print_screen#0 ← ((byte*)) (word/signed word/dword/signed dword) 1024 + (byte*) print_line_cursor#0 ← (byte*) print_screen#0 + (byte*) print_char_cursor#0 ← (byte*) print_line_cursor#0 + to:@10 +print_ln: scope:[print_ln] from print_plex::@2 + (byte*) print_char_cursor#36 ← phi( print_plex::@2/(byte*) print_char_cursor#41 ) + (byte*) print_line_cursor#23 ← phi( print_plex::@2/(byte*) print_line_cursor#26 ) + to:print_ln::@1 +print_ln::@1: scope:[print_ln] from print_ln print_ln::@1 + (byte*) print_char_cursor#19 ← phi( print_ln/(byte*) print_char_cursor#36 print_ln::@1/(byte*) print_char_cursor#19 ) + (byte*) print_line_cursor#12 ← phi( print_ln/(byte*) print_line_cursor#23 print_ln::@1/(byte*) print_line_cursor#1 ) + (byte*~) print_ln::$0 ← (byte*) print_line_cursor#12 + (byte/signed byte/word/signed word/dword/signed dword) 40 + (byte*) print_line_cursor#1 ← (byte*~) print_ln::$0 + (bool~) print_ln::$1 ← (byte*) print_line_cursor#1 < (byte*) print_char_cursor#19 + if((bool~) print_ln::$1) goto print_ln::@1 + to:print_ln::@2 +print_ln::@2: scope:[print_ln] from print_ln::@1 + (byte*) print_line_cursor#13 ← phi( print_ln::@1/(byte*) print_line_cursor#1 ) + (byte*) print_char_cursor#1 ← (byte*) print_line_cursor#13 + to:print_ln::@return +print_ln::@return: scope:[print_ln] from print_ln::@2 + (byte*) print_char_cursor#20 ← phi( print_ln::@2/(byte*) print_char_cursor#1 ) + (byte*) print_line_cursor#14 ← phi( print_ln::@2/(byte*) print_line_cursor#13 ) + (byte*) print_line_cursor#2 ← (byte*) print_line_cursor#14 + (byte*) print_char_cursor#2 ← (byte*) print_char_cursor#20 + return + to:@return +@10: scope:[] from @begin + (byte*) print_screen#8 ← phi( @begin/(byte*) print_screen#0 ) + (byte*) print_char_cursor#46 ← phi( @begin/(byte*) print_char_cursor#0 ) + (byte*) print_line_cursor#31 ← phi( @begin/(byte*) print_line_cursor#0 ) + (byte[]) print_hextab#0 ← (const string) $1 + to:@14 +print_byte: scope:[print_byte] from print_plex::@1 + (byte*) print_char_cursor#37 ← phi( print_plex::@1/(byte*) print_char_cursor#40 ) + (byte) print_byte::b#1 ← phi( print_plex::@1/(byte) print_byte::b#0 ) + (byte~) print_byte::$0 ← (byte) print_byte::b#1 >> (byte/signed byte/word/signed word/dword/signed dword) 4 + (byte) print_char::ch#0 ← *((byte[]) print_hextab#0 + (byte~) print_byte::$0) + call print_char + to:print_byte::@1 +print_byte::@1: scope:[print_byte] from print_byte + (byte) print_byte::b#2 ← phi( print_byte/(byte) print_byte::b#1 ) + (byte*) print_char_cursor#21 ← phi( print_byte/(byte*) print_char_cursor#7 ) + (byte*) print_char_cursor#3 ← (byte*) print_char_cursor#21 + (byte~) print_byte::$2 ← (byte) print_byte::b#2 & (byte/signed byte/word/signed word/dword/signed dword) 15 + (byte) print_char::ch#1 ← *((byte[]) print_hextab#0 + (byte~) print_byte::$2) + call print_char + to:print_byte::@2 +print_byte::@2: scope:[print_byte] from print_byte::@1 + (byte*) print_char_cursor#22 ← phi( print_byte::@1/(byte*) print_char_cursor#7 ) + (byte*) print_char_cursor#4 ← (byte*) print_char_cursor#22 + to:print_byte::@return +print_byte::@return: scope:[print_byte] from print_byte::@2 + (byte*) print_char_cursor#23 ← phi( print_byte::@2/(byte*) print_char_cursor#4 ) + (byte*) print_char_cursor#5 ← (byte*) print_char_cursor#23 + return + to:@return +print_char: scope:[print_char] from print_byte print_byte::@1 print_plex::@3 + (byte*) print_char_cursor#24 ← phi( print_byte/(byte*) print_char_cursor#37 print_byte::@1/(byte*) print_char_cursor#3 print_plex::@3/(byte*) print_char_cursor#14 ) + (byte) print_char::ch#3 ← phi( print_byte/(byte) print_char::ch#0 print_byte::@1/(byte) print_char::ch#1 print_plex::@3/(byte) print_char::ch#2 ) + *((byte*) print_char_cursor#24) ← (byte) print_char::ch#3 + (byte*) print_char_cursor#6 ← ++ (byte*) print_char_cursor#24 + to:print_char::@return +print_char::@return: scope:[print_char] from print_char + (byte*) print_char_cursor#25 ← phi( print_char/(byte*) print_char_cursor#6 ) + (byte*) print_char_cursor#7 ← (byte*) print_char_cursor#25 + return + to:@return +print_cls: scope:[print_cls] from main::@1 + (byte*) print_screen#1 ← phi( main::@1/(byte*) print_screen#4 ) + (byte*) print_cls::sc#0 ← (byte*) print_screen#1 + to:print_cls::@1 +print_cls::@1: scope:[print_cls] from print_cls print_cls::@1 + (byte*) print_screen#2 ← phi( print_cls/(byte*) print_screen#1 print_cls::@1/(byte*) print_screen#2 ) + (byte*) print_cls::sc#2 ← phi( print_cls/(byte*) print_cls::sc#0 print_cls::@1/(byte*) print_cls::sc#1 ) + *((byte*) print_cls::sc#2) ← (byte) ' ' + (byte*) print_cls::sc#1 ← ++ (byte*) print_cls::sc#2 + (byte*~) print_cls::$0 ← (byte*) print_screen#2 + (word/signed word/dword/signed dword) 1000 + (bool~) print_cls::$1 ← (byte*) print_cls::sc#1 != (byte*~) print_cls::$0 + if((bool~) print_cls::$1) goto print_cls::@1 + to:print_cls::@2 +print_cls::@2: scope:[print_cls] from print_cls::@1 + (byte*) print_screen#3 ← phi( print_cls::@1/(byte*) print_screen#2 ) + (byte*) print_line_cursor#3 ← (byte*) print_screen#3 + (byte*) print_char_cursor#8 ← (byte*) print_line_cursor#3 + to:print_cls::@return +print_cls::@return: scope:[print_cls] from print_cls::@2 + (byte*) print_char_cursor#26 ← phi( print_cls::@2/(byte*) print_char_cursor#8 ) + (byte*) print_line_cursor#15 ← phi( print_cls::@2/(byte*) print_line_cursor#3 ) + (byte*) print_line_cursor#4 ← (byte*) print_line_cursor#15 + (byte*) print_char_cursor#9 ← (byte*) print_char_cursor#26 + return + to:@return +@14: scope:[] from @10 + (byte*) print_screen#7 ← phi( @10/(byte*) print_screen#8 ) + (byte*) print_char_cursor#45 ← phi( @10/(byte*) print_char_cursor#46 ) + (byte*) print_line_cursor#30 ← phi( @10/(byte*) print_line_cursor#31 ) + (byte) PLEX_COUNT#0 ← (byte/signed byte/word/signed word/dword/signed dword) 10 + (byte[PLEX_COUNT#0]) PLEX_YPOS#0 ← { (byte/word/signed word/dword/signed dword) 255, (byte/signed byte/word/signed word/dword/signed dword) 18, (byte/signed byte/word/signed word/dword/signed dword) 17, (byte/signed byte/word/signed word/dword/signed dword) 52, (byte/signed byte/word/signed word/dword/signed dword) 2, (byte/word/signed word/dword/signed dword) 129, (byte/signed byte/word/signed word/dword/signed dword) 119, (byte/word/signed word/dword/signed dword) 129, (byte/word/signed word/dword/signed dword) 239, (byte/signed byte/word/signed word/dword/signed dword) 17 } + (byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 ← { fill( PLEX_COUNT#0, 0) } + to:@19 +plexInit: scope:[plexInit] from main + (byte/signed word/word/dword/signed dword~) plexInit::$0 ← (byte) PLEX_COUNT#0 - (byte/signed byte/word/signed word/dword/signed dword) 1 + (byte) plexInit::i#0 ← (byte/signed byte/word/signed word/dword/signed dword) 0 + to:plexInit::@1 +plexInit::@1: scope:[plexInit] from plexInit plexInit::@1 + (byte) plexInit::i#2 ← phi( plexInit/(byte) plexInit::i#0 plexInit::@1/(byte) plexInit::i#1 ) + *((byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexInit::i#2) ← (byte) plexInit::i#2 + (byte) plexInit::i#1 ← (byte) plexInit::i#2 + rangenext(0,plexInit::$0) + (bool~) plexInit::$1 ← (byte) plexInit::i#1 != rangelast(0,plexInit::$0) + if((bool~) plexInit::$1) goto plexInit::@1 + to:plexInit::@return +plexInit::@return: scope:[plexInit] from plexInit::@1 + return + to:@return +plexSort: scope:[plexSort] from main::@3 + (byte/signed word/word/dword/signed dword~) plexSort::$0 ← (byte) PLEX_COUNT#0 - (byte/signed byte/word/signed word/dword/signed dword) 2 + (byte) plexSort::m#0 ← (byte/signed byte/word/signed word/dword/signed dword) 0 + to:plexSort::@1 +plexSort::@1: scope:[plexSort] from plexSort plexSort::@2 + (byte) plexSort::m#2 ← phi( plexSort/(byte) plexSort::m#0 plexSort::@2/(byte) plexSort::m#1 ) + (byte/signed word/word/dword/signed dword~) plexSort::$1 ← (byte) plexSort::m#2 + (byte/signed byte/word/signed word/dword/signed dword) 1 + (byte) plexSort::nxt_idx#0 ← *((byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte/signed word/word/dword/signed dword~) plexSort::$1) + (byte) plexSort::nxt_y#0 ← *((byte[PLEX_COUNT#0]) PLEX_YPOS#0 + (byte) plexSort::nxt_idx#0) + (byte) plexSort::cur_idx#0 ← *((byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::m#2) + (bool~) plexSort::$2 ← (byte) plexSort::nxt_y#0 < *((byte[PLEX_COUNT#0]) PLEX_YPOS#0 + (byte) plexSort::cur_idx#0) + (bool~) plexSort::$3 ← ! (bool~) plexSort::$2 + if((bool~) plexSort::$3) goto plexSort::@2 + to:plexSort::@4 +plexSort::@2: scope:[plexSort] from plexSort::@1 plexSort::@5 + (byte) plexSort::m#3 ← phi( plexSort::@1/(byte) plexSort::m#2 plexSort::@5/(byte) plexSort::m#5 ) + (byte) plexSort::m#1 ← (byte) plexSort::m#3 + rangenext(0,plexSort::$0) + (bool~) plexSort::$8 ← (byte) plexSort::m#1 != rangelast(0,plexSort::$0) + if((bool~) plexSort::$8) goto plexSort::@1 + to:plexSort::@return +plexSort::@4: scope:[plexSort] from plexSort::@1 + (byte) plexSort::nxt_idx#3 ← phi( plexSort::@1/(byte) plexSort::nxt_idx#0 ) + (byte) plexSort::nxt_y#2 ← phi( plexSort::@1/(byte) plexSort::nxt_y#0 ) + (byte) plexSort::m#4 ← phi( plexSort::@1/(byte) plexSort::m#2 ) + (byte) plexSort::s#0 ← (byte) plexSort::m#4 + to:plexSort::@3 +plexSort::@3: scope:[plexSort] from plexSort::@3 plexSort::@4 + (byte) plexSort::m#6 ← phi( plexSort::@3/(byte) plexSort::m#6 plexSort::@4/(byte) plexSort::m#4 ) + (byte) plexSort::nxt_idx#2 ← phi( plexSort::@3/(byte) plexSort::nxt_idx#2 plexSort::@4/(byte) plexSort::nxt_idx#3 ) + (byte) plexSort::nxt_y#1 ← phi( plexSort::@3/(byte) plexSort::nxt_y#1 plexSort::@4/(byte) plexSort::nxt_y#2 ) + (byte) plexSort::s#3 ← phi( plexSort::@3/(byte) plexSort::s#1 plexSort::@4/(byte) plexSort::s#0 ) + (byte/signed word/word/dword/signed dword~) plexSort::$4 ← (byte) plexSort::s#3 + (byte/signed byte/word/signed word/dword/signed dword) 1 + *((byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte/signed word/word/dword/signed dword~) plexSort::$4) ← *((byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#3) + (byte) plexSort::s#1 ← -- (byte) plexSort::s#3 + (bool~) plexSort::$5 ← (byte) plexSort::s#1 != (byte/word/signed word/dword/signed dword) 255 + (bool~) plexSort::$6 ← (byte) plexSort::nxt_y#1 < *((byte[PLEX_COUNT#0]) PLEX_YPOS#0 + *((byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#1)) + (bool~) plexSort::$7 ← (bool~) plexSort::$5 && (bool~) plexSort::$6 + if((bool~) plexSort::$7) goto plexSort::@3 + to:plexSort::@5 +plexSort::@5: scope:[plexSort] from plexSort::@3 + (byte) plexSort::m#5 ← phi( plexSort::@3/(byte) plexSort::m#6 ) + (byte) plexSort::nxt_idx#1 ← phi( plexSort::@3/(byte) plexSort::nxt_idx#2 ) + (byte) plexSort::s#4 ← phi( plexSort::@3/(byte) plexSort::s#1 ) + (byte) plexSort::s#2 ← ++ (byte) plexSort::s#4 + *((byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#2) ← (byte) plexSort::nxt_idx#1 + to:plexSort::@2 +plexSort::@return: scope:[plexSort] from plexSort::@2 + return + to:@return +main: scope:[main] from @19 + (byte*) print_char_cursor#43 ← phi( @19/(byte*) print_char_cursor#42 ) + (byte*) print_line_cursor#28 ← phi( @19/(byte*) print_line_cursor#27 ) + (byte*) print_screen#5 ← phi( @19/(byte*) print_screen#6 ) + call plexInit + to:main::@1 +main::@1: scope:[main] from main + (byte*) print_char_cursor#38 ← phi( main/(byte*) print_char_cursor#43 ) + (byte*) print_line_cursor#24 ← phi( main/(byte*) print_line_cursor#28 ) + (byte*) print_screen#4 ← phi( main/(byte*) print_screen#5 ) + call print_cls + to:main::@2 +main::@2: scope:[main] from main::@1 + (byte*) print_char_cursor#27 ← phi( main::@1/(byte*) print_char_cursor#9 ) + (byte*) print_line_cursor#16 ← phi( main::@1/(byte*) print_line_cursor#4 ) + (byte*) print_line_cursor#5 ← (byte*) print_line_cursor#16 + (byte*) print_char_cursor#10 ← (byte*) print_char_cursor#27 + call print_plex + to:main::@3 +main::@3: scope:[main] from main::@2 + (byte*) print_line_cursor#17 ← phi( main::@2/(byte*) print_line_cursor#10 ) + (byte*) print_char_cursor#28 ← phi( main::@2/(byte*) print_char_cursor#17 ) + (byte*) print_char_cursor#11 ← (byte*) print_char_cursor#28 + (byte*) print_line_cursor#6 ← (byte*) print_line_cursor#17 + call plexSort + to:main::@4 +main::@4: scope:[main] from main::@3 + (byte*) print_line_cursor#25 ← phi( main::@3/(byte*) print_line_cursor#6 ) + (byte*) print_char_cursor#39 ← phi( main::@3/(byte*) print_char_cursor#11 ) + call print_plex + to:main::@5 +main::@5: scope:[main] from main::@4 + (byte*) print_line_cursor#18 ← phi( main::@4/(byte*) print_line_cursor#10 ) + (byte*) print_char_cursor#29 ← phi( main::@4/(byte*) print_char_cursor#17 ) + (byte*) print_char_cursor#12 ← (byte*) print_char_cursor#29 + (byte*) print_line_cursor#7 ← (byte*) print_line_cursor#18 + to:main::@return +main::@return: scope:[main] from main::@5 + (byte*) print_char_cursor#30 ← phi( main::@5/(byte*) print_char_cursor#12 ) + (byte*) print_line_cursor#19 ← phi( main::@5/(byte*) print_line_cursor#7 ) + (byte*) print_line_cursor#8 ← (byte*) print_line_cursor#19 + (byte*) print_char_cursor#13 ← (byte*) print_char_cursor#30 + return + to:@return +print_plex: scope:[print_plex] from main::@2 main::@4 + (byte*) print_line_cursor#34 ← phi( main::@2/(byte*) print_line_cursor#5 main::@4/(byte*) print_line_cursor#25 ) + (byte*) print_char_cursor#44 ← phi( main::@2/(byte*) print_char_cursor#10 main::@4/(byte*) print_char_cursor#39 ) + (byte/signed word/word/dword/signed dword~) print_plex::$0 ← (byte) PLEX_COUNT#0 - (byte/signed byte/word/signed word/dword/signed dword) 1 + (byte) print_plex::i#0 ← (byte/signed byte/word/signed word/dword/signed dword) 0 + to:print_plex::@1 +print_plex::@1: scope:[print_plex] from print_plex print_plex::@4 + (byte*) print_line_cursor#33 ← phi( print_plex/(byte*) print_line_cursor#34 print_plex::@4/(byte*) print_line_cursor#29 ) + (byte*) print_char_cursor#40 ← phi( print_plex/(byte*) print_char_cursor#44 print_plex::@4/(byte*) print_char_cursor#15 ) + (byte) print_plex::i#2 ← phi( print_plex/(byte) print_plex::i#0 print_plex::@4/(byte) print_plex::i#1 ) + (byte) print_byte::b#0 ← *((byte[PLEX_COUNT#0]) PLEX_YPOS#0 + *((byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) print_plex::i#2)) + call print_byte + to:print_plex::@3 +print_plex::@3: scope:[print_plex] from print_plex::@1 + (byte*) print_line_cursor#32 ← phi( print_plex::@1/(byte*) print_line_cursor#33 ) + (byte) print_plex::i#4 ← phi( print_plex::@1/(byte) print_plex::i#2 ) + (byte*) print_char_cursor#31 ← phi( print_plex::@1/(byte*) print_char_cursor#5 ) + (byte*) print_char_cursor#14 ← (byte*) print_char_cursor#31 + (byte) print_char::ch#2 ← (byte) ' ' + call print_char + to:print_plex::@4 +print_plex::@4: scope:[print_plex] from print_plex::@3 + (byte*) print_line_cursor#29 ← phi( print_plex::@3/(byte*) print_line_cursor#32 ) + (byte) print_plex::i#3 ← phi( print_plex::@3/(byte) print_plex::i#4 ) + (byte*) print_char_cursor#32 ← phi( print_plex::@3/(byte*) print_char_cursor#7 ) + (byte*) print_char_cursor#15 ← (byte*) print_char_cursor#32 + (byte) print_plex::i#1 ← (byte) print_plex::i#3 + rangenext(0,print_plex::$0) + (bool~) print_plex::$3 ← (byte) print_plex::i#1 != rangelast(0,print_plex::$0) + if((bool~) print_plex::$3) goto print_plex::@1 + to:print_plex::@2 +print_plex::@2: scope:[print_plex] from print_plex::@4 + (byte*) print_char_cursor#41 ← phi( print_plex::@4/(byte*) print_char_cursor#15 ) + (byte*) print_line_cursor#26 ← phi( print_plex::@4/(byte*) print_line_cursor#29 ) + call print_ln + to:print_plex::@5 +print_plex::@5: scope:[print_plex] from print_plex::@2 + (byte*) print_char_cursor#33 ← phi( print_plex::@2/(byte*) print_char_cursor#2 ) + (byte*) print_line_cursor#20 ← phi( print_plex::@2/(byte*) print_line_cursor#2 ) + (byte*) print_line_cursor#9 ← (byte*) print_line_cursor#20 + (byte*) print_char_cursor#16 ← (byte*) print_char_cursor#33 + to:print_plex::@return +print_plex::@return: scope:[print_plex] from print_plex::@5 + (byte*) print_line_cursor#21 ← phi( print_plex::@5/(byte*) print_line_cursor#9 ) + (byte*) print_char_cursor#34 ← phi( print_plex::@5/(byte*) print_char_cursor#16 ) + (byte*) print_char_cursor#17 ← (byte*) print_char_cursor#34 + (byte*) print_line_cursor#10 ← (byte*) print_line_cursor#21 + return + to:@return +@19: scope:[] from @14 + (byte*) print_screen#6 ← phi( @14/(byte*) print_screen#7 ) + (byte*) print_char_cursor#42 ← phi( @14/(byte*) print_char_cursor#45 ) + (byte*) print_line_cursor#27 ← phi( @14/(byte*) print_line_cursor#30 ) + call main + to:@20 +@20: scope:[] from @19 + (byte*) print_char_cursor#35 ← phi( @19/(byte*) print_char_cursor#13 ) + (byte*) print_line_cursor#22 ← phi( @19/(byte*) print_line_cursor#8 ) + (byte*) print_line_cursor#11 ← (byte*) print_line_cursor#22 + (byte*) print_char_cursor#18 ← (byte*) print_char_cursor#35 + to:@end +@end: scope:[] from @20 + +SYMBOL TABLE SSA +(const string) $1 = (string) "0123456789abcdef" +(label) @10 +(label) @14 +(label) @19 +(label) @20 +(label) @begin +(label) @end +(byte) PLEX_COUNT +(byte) PLEX_COUNT#0 +(byte[PLEX_COUNT#0]) PLEX_SORTED_IDX +(byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 +(byte[PLEX_COUNT#0]) PLEX_YPOS +(byte[PLEX_COUNT#0]) PLEX_YPOS#0 +(void()) main() +(label) main::@1 +(label) main::@2 +(label) main::@3 +(label) main::@4 +(label) main::@5 +(label) main::@return +(void()) plexInit() +(byte/signed word/word/dword/signed dword~) plexInit::$0 +(bool~) plexInit::$1 +(label) plexInit::@1 +(label) plexInit::@return +(byte) plexInit::i +(byte) plexInit::i#0 +(byte) plexInit::i#1 +(byte) plexInit::i#2 +(void()) plexSort() +(byte/signed word/word/dword/signed dword~) plexSort::$0 +(byte/signed word/word/dword/signed dword~) plexSort::$1 +(bool~) plexSort::$2 +(bool~) plexSort::$3 +(byte/signed word/word/dword/signed dword~) plexSort::$4 +(bool~) plexSort::$5 +(bool~) plexSort::$6 +(bool~) plexSort::$7 +(bool~) plexSort::$8 +(label) plexSort::@1 +(label) plexSort::@2 +(label) plexSort::@3 +(label) plexSort::@4 +(label) plexSort::@5 +(label) plexSort::@return +(byte) plexSort::cur_idx +(byte) plexSort::cur_idx#0 +(byte) plexSort::m +(byte) plexSort::m#0 +(byte) plexSort::m#1 +(byte) plexSort::m#2 +(byte) plexSort::m#3 +(byte) plexSort::m#4 +(byte) plexSort::m#5 +(byte) plexSort::m#6 +(byte) plexSort::nxt_idx +(byte) plexSort::nxt_idx#0 +(byte) plexSort::nxt_idx#1 +(byte) plexSort::nxt_idx#2 +(byte) plexSort::nxt_idx#3 +(byte) plexSort::nxt_y +(byte) plexSort::nxt_y#0 +(byte) plexSort::nxt_y#1 +(byte) plexSort::nxt_y#2 +(byte) plexSort::s +(byte) plexSort::s#0 +(byte) plexSort::s#1 +(byte) plexSort::s#2 +(byte) plexSort::s#3 +(byte) plexSort::s#4 +(void()) print_byte((byte) print_byte::b) +(byte~) print_byte::$0 +(byte~) print_byte::$2 +(label) print_byte::@1 +(label) print_byte::@2 +(label) print_byte::@return +(byte) print_byte::b +(byte) print_byte::b#0 +(byte) print_byte::b#1 +(byte) print_byte::b#2 +(void()) print_char((byte) print_char::ch) +(label) print_char::@return +(byte) print_char::ch +(byte) print_char::ch#0 +(byte) print_char::ch#1 +(byte) print_char::ch#2 +(byte) print_char::ch#3 +(byte*) print_char_cursor +(byte*) print_char_cursor#0 +(byte*) print_char_cursor#1 +(byte*) print_char_cursor#10 +(byte*) print_char_cursor#11 +(byte*) print_char_cursor#12 +(byte*) print_char_cursor#13 +(byte*) print_char_cursor#14 +(byte*) print_char_cursor#15 +(byte*) print_char_cursor#16 +(byte*) print_char_cursor#17 +(byte*) print_char_cursor#18 +(byte*) print_char_cursor#19 +(byte*) print_char_cursor#2 +(byte*) print_char_cursor#20 +(byte*) print_char_cursor#21 +(byte*) print_char_cursor#22 +(byte*) print_char_cursor#23 +(byte*) print_char_cursor#24 +(byte*) print_char_cursor#25 +(byte*) print_char_cursor#26 +(byte*) print_char_cursor#27 +(byte*) print_char_cursor#28 +(byte*) print_char_cursor#29 +(byte*) print_char_cursor#3 +(byte*) print_char_cursor#30 +(byte*) print_char_cursor#31 +(byte*) print_char_cursor#32 +(byte*) print_char_cursor#33 +(byte*) print_char_cursor#34 +(byte*) print_char_cursor#35 +(byte*) print_char_cursor#36 +(byte*) print_char_cursor#37 +(byte*) print_char_cursor#38 +(byte*) print_char_cursor#39 +(byte*) print_char_cursor#4 +(byte*) print_char_cursor#40 +(byte*) print_char_cursor#41 +(byte*) print_char_cursor#42 +(byte*) print_char_cursor#43 +(byte*) print_char_cursor#44 +(byte*) print_char_cursor#45 +(byte*) print_char_cursor#46 +(byte*) print_char_cursor#5 +(byte*) print_char_cursor#6 +(byte*) print_char_cursor#7 +(byte*) print_char_cursor#8 +(byte*) print_char_cursor#9 +(void()) print_cls() +(byte*~) print_cls::$0 +(bool~) print_cls::$1 +(label) print_cls::@1 +(label) print_cls::@2 +(label) print_cls::@return +(byte*) print_cls::sc +(byte*) print_cls::sc#0 +(byte*) print_cls::sc#1 +(byte*) print_cls::sc#2 +(byte[]) print_hextab +(byte[]) print_hextab#0 +(byte*) print_line_cursor +(byte*) print_line_cursor#0 +(byte*) print_line_cursor#1 +(byte*) print_line_cursor#10 +(byte*) print_line_cursor#11 +(byte*) print_line_cursor#12 +(byte*) print_line_cursor#13 +(byte*) print_line_cursor#14 +(byte*) print_line_cursor#15 +(byte*) print_line_cursor#16 +(byte*) print_line_cursor#17 +(byte*) print_line_cursor#18 +(byte*) print_line_cursor#19 +(byte*) print_line_cursor#2 +(byte*) print_line_cursor#20 +(byte*) print_line_cursor#21 +(byte*) print_line_cursor#22 +(byte*) print_line_cursor#23 +(byte*) print_line_cursor#24 +(byte*) print_line_cursor#25 +(byte*) print_line_cursor#26 +(byte*) print_line_cursor#27 +(byte*) print_line_cursor#28 +(byte*) print_line_cursor#29 +(byte*) print_line_cursor#3 +(byte*) print_line_cursor#30 +(byte*) print_line_cursor#31 +(byte*) print_line_cursor#32 +(byte*) print_line_cursor#33 +(byte*) print_line_cursor#34 +(byte*) print_line_cursor#4 +(byte*) print_line_cursor#5 +(byte*) print_line_cursor#6 +(byte*) print_line_cursor#7 +(byte*) print_line_cursor#8 +(byte*) print_line_cursor#9 +(void()) print_ln() +(byte*~) print_ln::$0 +(bool~) print_ln::$1 +(label) print_ln::@1 +(label) print_ln::@2 +(label) print_ln::@return +(void()) print_plex() +(byte/signed word/word/dword/signed dword~) print_plex::$0 +(bool~) print_plex::$3 +(label) print_plex::@1 +(label) print_plex::@2 +(label) print_plex::@3 +(label) print_plex::@4 +(label) print_plex::@5 +(label) print_plex::@return +(byte) print_plex::i +(byte) print_plex::i#0 +(byte) print_plex::i#1 +(byte) print_plex::i#2 +(byte) print_plex::i#3 +(byte) print_plex::i#4 +(byte*) print_screen +(byte*) print_screen#0 +(byte*) print_screen#1 +(byte*) print_screen#2 +(byte*) print_screen#3 +(byte*) print_screen#4 +(byte*) print_screen#5 +(byte*) print_screen#6 +(byte*) print_screen#7 +(byte*) print_screen#8 + +OPTIMIZING CONTROL FLOW GRAPH +Inversing boolean not (bool~) plexSort::$3 ← (byte) plexSort::nxt_y#0 >= *((byte[PLEX_COUNT#0]) PLEX_YPOS#0 + (byte) plexSort::cur_idx#0) from (bool~) plexSort::$2 ← (byte) plexSort::nxt_y#0 < *((byte[PLEX_COUNT#0]) PLEX_YPOS#0 + (byte) plexSort::cur_idx#0) +Succesful SSA optimization Pass2UnaryNotSimplification +Not aliassing across scopes: print_line_cursor#23 print_line_cursor#26 +Not aliassing across scopes: print_char_cursor#36 print_char_cursor#41 +Not aliassing across scopes: print_byte::b#1 print_byte::b#0 +Not aliassing across scopes: print_char_cursor#37 print_char_cursor#40 +Not aliassing across scopes: print_char_cursor#21 print_char_cursor#7 +Not aliassing across scopes: print_char_cursor#22 print_char_cursor#7 +Not aliassing across scopes: print_char::ch#3 print_char::ch#0 +Not aliassing across scopes: print_char_cursor#24 print_char_cursor#37 +Not aliassing across scopes: print_screen#1 print_screen#4 +Not aliassing across scopes: print_cls::sc#0 print_screen#1 +Not aliassing identity: plexSort::nxt_y#1 plexSort::nxt_y#1 +Not aliassing identity: plexSort::nxt_idx#2 plexSort::nxt_idx#2 +Not aliassing identity: plexSort::m#6 plexSort::m#6 +Not aliassing across scopes: print_screen#5 print_screen#6 +Not aliassing across scopes: print_line_cursor#28 print_line_cursor#27 +Not aliassing across scopes: print_char_cursor#43 print_char_cursor#42 +Not aliassing across scopes: print_line_cursor#16 print_line_cursor#4 +Not aliassing across scopes: print_char_cursor#27 print_char_cursor#9 +Not aliassing across scopes: print_char_cursor#28 print_char_cursor#17 +Not aliassing across scopes: print_line_cursor#17 print_line_cursor#10 +Not aliassing across scopes: print_char_cursor#29 print_char_cursor#17 +Not aliassing across scopes: print_line_cursor#18 print_line_cursor#10 +Not aliassing across scopes: print_char_cursor#44 print_char_cursor#10 +Not aliassing across scopes: print_line_cursor#34 print_line_cursor#5 +Not aliassing across scopes: print_char_cursor#31 print_char_cursor#5 +Not aliassing across scopes: print_char_cursor#32 print_char_cursor#7 +Not aliassing across scopes: print_line_cursor#20 print_line_cursor#2 +Not aliassing across scopes: print_char_cursor#33 print_char_cursor#2 +Not aliassing across scopes: print_line_cursor#22 print_line_cursor#8 +Not aliassing across scopes: print_char_cursor#35 print_char_cursor#13 +Alias (byte*) print_line_cursor#0 = (byte*) print_screen#0 (byte*) print_char_cursor#0 (byte*) print_line_cursor#31 (byte*) print_char_cursor#46 (byte*) print_screen#8 (byte*) print_line_cursor#30 (byte*) print_char_cursor#45 (byte*) print_screen#7 (byte*) print_line_cursor#27 (byte*) print_char_cursor#42 (byte*) print_screen#6 +Alias (byte*) print_line_cursor#1 = (byte*~) print_ln::$0 (byte*) print_line_cursor#13 (byte*) print_char_cursor#1 (byte*) print_line_cursor#14 (byte*) print_char_cursor#20 (byte*) print_line_cursor#2 (byte*) print_char_cursor#2 +Alias (byte) print_byte::b#1 = (byte) print_byte::b#2 +Alias (byte*) print_char_cursor#21 = (byte*) print_char_cursor#3 +Alias (byte*) print_char_cursor#22 = (byte*) print_char_cursor#4 (byte*) print_char_cursor#23 (byte*) print_char_cursor#5 +Alias (byte*) print_char_cursor#25 = (byte*) print_char_cursor#6 (byte*) print_char_cursor#7 +Alias (byte*) print_line_cursor#15 = (byte*) print_screen#3 (byte*) print_screen#2 (byte*) print_line_cursor#3 (byte*) print_char_cursor#8 (byte*) print_char_cursor#26 (byte*) print_line_cursor#4 (byte*) print_char_cursor#9 +Alias (byte) plexSort::m#2 = (byte) plexSort::m#4 (byte) plexSort::s#0 +Alias (byte) plexSort::nxt_y#0 = (byte) plexSort::nxt_y#2 +Alias (byte) plexSort::nxt_idx#0 = (byte) plexSort::nxt_idx#3 +Alias (byte) plexSort::s#1 = (byte) plexSort::s#4 +Alias (byte) plexSort::nxt_idx#1 = (byte) plexSort::nxt_idx#2 +Alias (byte) plexSort::m#5 = (byte) plexSort::m#6 +Alias (byte*) print_screen#4 = (byte*) print_screen#5 +Alias (byte*) print_line_cursor#24 = (byte*) print_line_cursor#28 +Alias (byte*) print_char_cursor#38 = (byte*) print_char_cursor#43 +Alias (byte*) print_line_cursor#16 = (byte*) print_line_cursor#5 +Alias (byte*) print_char_cursor#10 = (byte*) print_char_cursor#27 +Alias (byte*) print_char_cursor#11 = (byte*) print_char_cursor#28 (byte*) print_char_cursor#39 +Alias (byte*) print_line_cursor#17 = (byte*) print_line_cursor#6 (byte*) print_line_cursor#25 +Alias (byte*) print_char_cursor#12 = (byte*) print_char_cursor#29 (byte*) print_char_cursor#30 (byte*) print_char_cursor#13 +Alias (byte*) print_line_cursor#18 = (byte*) print_line_cursor#7 (byte*) print_line_cursor#19 (byte*) print_line_cursor#8 +Alias (byte) print_plex::i#2 = (byte) print_plex::i#4 (byte) print_plex::i#3 +Alias (byte*) print_line_cursor#26 = (byte*) print_line_cursor#32 (byte*) print_line_cursor#33 (byte*) print_line_cursor#29 +Alias (byte*) print_char_cursor#14 = (byte*) print_char_cursor#31 +Alias (byte*) print_char_cursor#15 = (byte*) print_char_cursor#32 (byte*) print_char_cursor#41 +Alias (byte*) print_line_cursor#10 = (byte*) print_line_cursor#9 (byte*) print_line_cursor#20 (byte*) print_line_cursor#21 +Alias (byte*) print_char_cursor#16 = (byte*) print_char_cursor#33 (byte*) print_char_cursor#34 (byte*) print_char_cursor#17 +Alias (byte*) print_line_cursor#11 = (byte*) print_line_cursor#22 +Alias (byte*) print_char_cursor#18 = (byte*) print_char_cursor#35 +Succesful SSA optimization Pass2AliasElimination +Not aliassing across scopes: print_line_cursor#23 print_line_cursor#26 +Not aliassing across scopes: print_char_cursor#36 print_char_cursor#15 +Not aliassing across scopes: print_byte::b#1 print_byte::b#0 +Not aliassing across scopes: print_char_cursor#37 print_char_cursor#40 +Not aliassing across scopes: print_char_cursor#21 print_char_cursor#25 +Not aliassing across scopes: print_char_cursor#22 print_char_cursor#25 +Not aliassing across scopes: print_char::ch#3 print_char::ch#0 +Not aliassing across scopes: print_char_cursor#24 print_char_cursor#37 +Not aliassing across scopes: print_screen#1 print_screen#4 +Not aliassing across scopes: print_cls::sc#0 print_screen#1 +Not aliassing identity: plexSort::nxt_y#1 plexSort::nxt_y#1 +Not aliassing identity: plexSort::nxt_idx#1 plexSort::nxt_idx#1 +Not aliassing identity: plexSort::m#5 plexSort::m#5 +Not aliassing across scopes: print_screen#4 print_line_cursor#0 +Not aliassing across scopes: print_line_cursor#24 print_line_cursor#0 +Not aliassing across scopes: print_char_cursor#38 print_line_cursor#0 +Not aliassing across scopes: print_line_cursor#16 print_line_cursor#15 +Not aliassing across scopes: print_char_cursor#10 print_line_cursor#15 +Not aliassing across scopes: print_char_cursor#11 print_char_cursor#16 +Not aliassing across scopes: print_line_cursor#17 print_line_cursor#10 +Not aliassing across scopes: print_char_cursor#12 print_char_cursor#16 +Not aliassing across scopes: print_line_cursor#18 print_line_cursor#10 +Not aliassing across scopes: print_char_cursor#44 print_char_cursor#10 +Not aliassing across scopes: print_line_cursor#34 print_line_cursor#16 +Not aliassing across scopes: print_char_cursor#14 print_char_cursor#22 +Not aliassing across scopes: print_char_cursor#15 print_char_cursor#25 +Not aliassing across scopes: print_line_cursor#10 print_line_cursor#1 +Not aliassing across scopes: print_char_cursor#16 print_line_cursor#1 +Not aliassing across scopes: print_line_cursor#11 print_line_cursor#18 +Not aliassing across scopes: print_char_cursor#18 print_char_cursor#12 +Self Phi Eliminated (byte*) print_char_cursor#19 +Self Phi Eliminated (byte*) print_line_cursor#15 +Self Phi Eliminated (byte) plexSort::nxt_y#1 +Self Phi Eliminated (byte) plexSort::nxt_idx#1 +Self Phi Eliminated (byte) plexSort::m#5 +Self Phi Eliminated (byte*) print_line_cursor#26 +Succesful SSA optimization Pass2SelfPhiElimination +Redundant Phi (byte*) print_line_cursor#23 (byte*) print_line_cursor#26 +Redundant Phi (byte*) print_char_cursor#36 (byte*) print_char_cursor#15 +Redundant Phi (byte*) print_char_cursor#19 (byte*) print_char_cursor#36 +Redundant Phi (byte) print_byte::b#1 (byte) print_byte::b#0 +Redundant Phi (byte*) print_char_cursor#37 (byte*) print_char_cursor#40 +Redundant Phi (byte*) print_char_cursor#21 (byte*) print_char_cursor#25 +Redundant Phi (byte*) print_char_cursor#22 (byte*) print_char_cursor#25 +Redundant Phi (byte*) print_screen#1 (byte*) print_screen#4 +Redundant Phi (byte*) print_line_cursor#15 (byte*) print_screen#1 +Redundant Phi (byte) plexSort::nxt_y#1 (byte) plexSort::nxt_y#0 +Redundant Phi (byte) plexSort::nxt_idx#1 (byte) plexSort::nxt_idx#0 +Redundant Phi (byte) plexSort::m#5 (byte) plexSort::m#2 +Redundant Phi (byte*) print_screen#4 (byte*) print_line_cursor#0 +Redundant Phi (byte*) print_line_cursor#24 (byte*) print_line_cursor#0 +Redundant Phi (byte*) print_char_cursor#38 (byte*) print_line_cursor#0 +Redundant Phi (byte*) print_line_cursor#16 (byte*) print_line_cursor#15 +Redundant Phi (byte*) print_char_cursor#10 (byte*) print_line_cursor#15 +Redundant Phi (byte*) print_char_cursor#11 (byte*) print_char_cursor#16 +Redundant Phi (byte*) print_line_cursor#17 (byte*) print_line_cursor#10 +Redundant Phi (byte*) print_char_cursor#12 (byte*) print_char_cursor#16 +Redundant Phi (byte*) print_line_cursor#18 (byte*) print_line_cursor#10 +Redundant Phi (byte*) print_line_cursor#26 (byte*) print_line_cursor#34 +Redundant Phi (byte*) print_char_cursor#14 (byte*) print_char_cursor#22 +Redundant Phi (byte*) print_char_cursor#15 (byte*) print_char_cursor#25 +Redundant Phi (byte*) print_line_cursor#10 (byte*) print_line_cursor#1 +Redundant Phi (byte*) print_char_cursor#16 (byte*) print_line_cursor#1 +Redundant Phi (byte*) print_line_cursor#11 (byte*) print_line_cursor#18 +Redundant Phi (byte*) print_char_cursor#18 (byte*) print_char_cursor#12 +Succesful SSA optimization Pass2RedundantPhiElimination +Redundant Phi (byte) plexSort::m#3 (byte) plexSort::m#2 +Succesful SSA optimization Pass2RedundantPhiElimination +Simple Condition (bool~) print_ln::$1 if((byte*) print_line_cursor#1<(byte*) print_char_cursor#25) goto print_ln::@1 +Simple Condition (bool~) print_cls::$1 if((byte*) print_cls::sc#1!=(byte*~) print_cls::$0) goto print_cls::@1 +Simple Condition (bool~) plexInit::$1 if((byte) plexInit::i#1!=rangelast(0,plexInit::$0)) goto plexInit::@1 +Simple Condition (bool~) plexSort::$3 if((byte) plexSort::nxt_y#0>=*((byte[PLEX_COUNT#0]) PLEX_YPOS#0 + (byte) plexSort::cur_idx#0)) goto plexSort::@2 +Simple Condition (bool~) plexSort::$8 if((byte) plexSort::m#1!=rangelast(0,plexSort::$0)) goto plexSort::@1 +Simple Condition (bool~) print_plex::$3 if((byte) print_plex::i#1!=rangelast(0,print_plex::$0)) goto print_plex::@1 +Succesful SSA optimization Pass2ConditionalJumpSimplification +Rewriting && if()-condition to two if()s (bool~) plexSort::$7 ← (bool~) plexSort::$5 && (bool~) plexSort::$6 +Succesful SSA optimization Pass2ConditionalAndOrRewriting +Constant (const byte*) print_line_cursor#0 = ((byte*))1024 +Constant (const byte[]) print_hextab#0 = $1 +Constant (const byte) PLEX_COUNT#0 = 10 +Constant (const byte[PLEX_COUNT#0]) PLEX_YPOS#0 = { 255, 18, 17, 52, 2, 129, 119, 129, 239, 17 } +Constant (const byte) plexInit::i#0 = 0 +Constant (const byte) plexSort::m#0 = 0 +Constant (const byte) print_plex::i#0 = 0 +Constant (const byte) print_char::ch#2 = ' ' +Succesful SSA optimization Pass2ConstantIdentification +Constant (const byte*) print_cls::sc#0 = print_line_cursor#0 +Constant (const byte*) print_cls::$0 = print_line_cursor#0+1000 +Constant (const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 = { fill( PLEX_COUNT#0, 0) } +Constant (const byte/signed word/word/dword/signed dword) plexInit::$0 = PLEX_COUNT#0-1 +Constant (const byte/signed word/word/dword/signed dword) plexSort::$0 = PLEX_COUNT#0-2 +Constant (const byte/signed word/word/dword/signed dword) print_plex::$0 = PLEX_COUNT#0-1 +Succesful SSA optimization Pass2ConstantIdentification +Consolidated array index constant in assignment *(PLEX_SORTED_IDX#0+1 + plexSort::$1) +Consolidated array index constant in assignment *(PLEX_SORTED_IDX#0+1 + plexSort::$4) +Succesful SSA optimization Pass2ConstantAdditionElimination +Inferred type updated to byte in (byte/signed word/word/dword/signed dword~) plexSort::$1 ← (byte) plexSort::m#2 +Inferred type updated to byte in (byte/signed word/word/dword/signed dword~) plexSort::$4 ← (byte) plexSort::s#3 +Resolved ranged next value plexInit::i#1 ← ++ plexInit::i#2 to ++ +Resolved ranged comparison value if(plexInit::i#1!=rangelast(0,plexInit::$0)) goto plexInit::@1 to (const byte/signed word/word/dword/signed dword) plexInit::$0+(byte/signed byte/word/signed word/dword/signed dword) 1 +Resolved ranged next value plexSort::m#1 ← ++ plexSort::m#2 to ++ +Resolved ranged comparison value if(plexSort::m#1!=rangelast(0,plexSort::$0)) goto plexSort::@1 to (const byte/signed word/word/dword/signed dword) plexSort::$0+(byte/signed byte/word/signed word/dword/signed dword) 1 +Resolved ranged next value print_plex::i#1 ← ++ print_plex::i#2 to ++ +Resolved ranged comparison value if(print_plex::i#1!=rangelast(0,print_plex::$0)) goto print_plex::@1 to (const byte/signed word/word/dword/signed dword) print_plex::$0+(byte/signed byte/word/signed word/dword/signed dword) 1 +Culled Empty Block (label) print_ln::@2 +Culled Empty Block (label) @10 +Culled Empty Block (label) print_byte::@2 +Culled Empty Block (label) print_cls::@2 +Culled Empty Block (label) @14 +Culled Empty Block (label) plexSort::@4 +Culled Empty Block (label) main::@5 +Culled Empty Block (label) print_plex::@5 +Culled Empty Block (label) @20 +Succesful SSA optimization Pass2CullEmptyBlocks +Not aliassing across scopes: print_line_cursor#12 print_line_cursor#34 +Not aliassing across scopes: print_char::ch#3 print_char::ch#0 +Not aliassing across scopes: print_char_cursor#24 print_char_cursor#40 +Alias (byte) plexSort::m#2 = (byte~) plexSort::$1 +Alias (byte) plexSort::s#3 = (byte~) plexSort::$4 +Succesful SSA optimization Pass2AliasElimination +Not aliassing across scopes: print_line_cursor#12 print_line_cursor#34 +Not aliassing across scopes: print_char::ch#3 print_char::ch#0 +Not aliassing across scopes: print_char_cursor#24 print_char_cursor#40 +Simple Condition (bool~) plexSort::$5 if((byte) plexSort::s#1!=(byte/word/signed word/dword/signed dword) 255) goto plexSort::@7 +Simple Condition (bool~) plexSort::$6 if((byte) plexSort::nxt_y#0<*((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#1))) goto plexSort::@3 +Succesful SSA optimization Pass2ConditionalJumpSimplification +Not aliassing across scopes: print_line_cursor#12 print_line_cursor#34 +Not aliassing across scopes: print_char::ch#3 print_char::ch#0 +Not aliassing across scopes: print_char_cursor#24 print_char_cursor#40 +OPTIMIZING CONTROL FLOW GRAPH +Inlining constant with var siblings (const byte) print_char::ch#2 +Inlining constant with var siblings (const byte) print_char::ch#2 +Inlining constant with var siblings (const byte) print_char::ch#2 +Inlining constant with var siblings (const byte*) print_cls::sc#0 +Inlining constant with var siblings (const byte*) print_cls::sc#0 +Inlining constant with var siblings (const byte) plexInit::i#0 +Inlining constant with var siblings (const byte) plexInit::i#0 +Inlining constant with var siblings (const byte) plexSort::m#0 +Inlining constant with var siblings (const byte) plexSort::m#0 +Inlining constant with var siblings (const byte) print_plex::i#0 +Inlining constant with var siblings (const byte) print_plex::i#0 +Inlining constant with var siblings (const byte*) print_line_cursor#0 +Inlining constant with var siblings (const byte*) print_line_cursor#0 +Inlining constant with var siblings (const byte*) print_line_cursor#0 +Constant inlined print_char::ch#2 = (byte) ' ' +Constant inlined print_cls::$0 = ((byte*))(word/signed word/dword/signed dword) 1024+(word/signed word/dword/signed dword) 1000 +Constant inlined plexInit::$0 = (const byte) PLEX_COUNT#0-(byte/signed byte/word/signed word/dword/signed dword) 1 +Constant inlined plexSort::$0 = (const byte) PLEX_COUNT#0-(byte/signed byte/word/signed word/dword/signed dword) 2 +Constant inlined print_line_cursor#0 = ((byte*))(word/signed word/dword/signed dword) 1024 +Constant inlined plexInit::i#0 = (byte/signed byte/word/signed word/dword/signed dword) 0 +Constant inlined plexSort::m#0 = (byte/signed byte/word/signed word/dword/signed dword) 0 +Constant inlined print_plex::i#0 = (byte/signed byte/word/signed word/dword/signed dword) 0 +Constant inlined print_cls::sc#0 = ((byte*))(word/signed word/dword/signed dword) 1024 +Constant inlined $1 = (const byte[]) print_hextab#0 +Constant inlined print_plex::$0 = (const byte) PLEX_COUNT#0-(byte/signed byte/word/signed word/dword/signed dword) 1 +Succesful SSA optimization Pass2ConstantInlining +Block Sequence Planned @begin @19 @end main main::@1 main::@2 main::@3 main::@4 main::@return print_plex print_plex::@1 print_plex::@3 print_plex::@4 print_plex::@2 print_plex::@return print_ln print_ln::@1 print_ln::@return print_char print_char::@return print_byte print_byte::@1 print_byte::@return plexSort plexSort::@1 plexSort::@3 plexSort::@5 plexSort::@2 plexSort::@return plexSort::@7 print_cls print_cls::@1 print_cls::@return plexInit plexInit::@1 plexInit::@return +Added new block during phi lifting print_plex::@6(between print_plex::@4 and print_plex::@1) +Added new block during phi lifting print_ln::@3(between print_ln::@1 and print_ln::@1) +Added new block during phi lifting plexSort::@8(between plexSort::@2 and plexSort::@1) +Added new block during phi lifting plexSort::@9(between plexSort::@7 and plexSort::@3) +Added new block during phi lifting plexSort::@10(between plexSort::@1 and plexSort::@3) +Added new block during phi lifting print_cls::@3(between print_cls::@1 and print_cls::@1) +Added new block during phi lifting plexInit::@3(between plexInit::@1 and plexInit::@1) +Block Sequence Planned @begin @19 @end main main::@1 main::@2 main::@3 main::@4 main::@return print_plex print_plex::@1 print_plex::@3 print_plex::@4 print_plex::@2 print_plex::@return print_plex::@6 print_ln print_ln::@1 print_ln::@return print_ln::@3 print_char print_char::@return print_byte print_byte::@1 print_byte::@return plexSort plexSort::@1 plexSort::@10 plexSort::@3 plexSort::@5 plexSort::@2 plexSort::@return plexSort::@8 plexSort::@7 plexSort::@9 print_cls print_cls::@1 print_cls::@return print_cls::@3 plexInit plexInit::@1 plexInit::@return plexInit::@3 +Adding NOP phi() at start of @begin +Adding NOP phi() at start of @19 +Adding NOP phi() at start of @end +Adding NOP phi() at start of main +Adding NOP phi() at start of main::@1 +Adding NOP phi() at start of main::@2 +Adding NOP phi() at start of main::@3 +Adding NOP phi() at start of print_plex::@2 +Adding NOP phi() at start of plexSort +Adding NOP phi() at start of print_cls +Adding NOP phi() at start of plexInit +CALL GRAPH +Calls in [] to main:2 +Calls in [main] to plexInit:5 print_cls:7 print_plex:9 plexSort:11 print_plex:14 +Calls in [print_plex] to print_byte:20 print_char:22 print_ln:26 +Calls in [print_byte] to print_char:44 print_char:49 + +Propagating live ranges... +Propagating live ranges... +Propagating live ranges... +Propagating live ranges... +Propagating live ranges... +Propagating live ranges... +Propagating live ranges... +Propagating live ranges... +Propagating live ranges... +Propagating live ranges... +Propagating live ranges... +Created 11 initial phi equivalence classes +Not coalescing [12] print_char_cursor#47 ← print_line_cursor#1 +Coalesced [13] print_line_cursor#35 ← print_line_cursor#1 +Coalesced [17] print_char_cursor#48 ← print_char_cursor#44 +Coalesced [21] print_char_cursor#52 ← print_char_cursor#25 +Coalesced [28] print_plex::i#5 ← print_plex::i#1 +Coalesced [29] print_char_cursor#49 ← print_char_cursor#25 +Coalesced [30] print_line_cursor#36 ← print_line_cursor#34 +Coalesced (already) [35] print_line_cursor#37 ← print_line_cursor#1 +Coalesced [42] print_char::ch#4 ← print_char::ch#0 +Coalesced (already) [43] print_char_cursor#50 ← print_char_cursor#40 +Coalesced [47] print_char::ch#5 ← print_char::ch#1 +Coalesced (already) [48] print_char_cursor#51 ← print_char_cursor#25 +Not coalescing [57] plexSort::s#6 ← plexSort::m#2 +Coalesced [67] plexSort::m#7 ← plexSort::m#1 +Coalesced [69] plexSort::s#5 ← plexSort::s#1 +Coalesced [76] print_cls::sc#3 ← print_cls::sc#1 +Coalesced [83] plexInit::i#3 ← plexInit::i#1 +Coalesced down to 8 phi equivalence classes +Culled Empty Block (label) print_plex::@6 +Culled Empty Block (label) print_ln::@3 +Culled Empty Block (label) plexSort::@8 +Culled Empty Block (label) plexSort::@9 +Culled Empty Block (label) print_cls::@3 +Culled Empty Block (label) plexInit::@3 +Block Sequence Planned @begin @19 @end main main::@1 main::@2 main::@3 main::@4 main::@return print_plex print_plex::@1 print_plex::@3 print_plex::@4 print_plex::@2 print_plex::@return print_ln print_ln::@1 print_ln::@return print_char print_char::@return print_byte print_byte::@1 print_byte::@return plexSort plexSort::@1 plexSort::@10 plexSort::@3 plexSort::@5 plexSort::@2 plexSort::@return plexSort::@7 print_cls print_cls::@1 print_cls::@return plexInit plexInit::@1 plexInit::@return +Adding NOP phi() at start of @begin +Adding NOP phi() at start of @19 +Adding NOP phi() at start of @end +Adding NOP phi() at start of main +Adding NOP phi() at start of main::@1 +Adding NOP phi() at start of main::@2 +Adding NOP phi() at start of main::@3 +Adding NOP phi() at start of print_plex::@3 +Adding NOP phi() at start of print_plex::@2 +Adding NOP phi() at start of print_ln +Adding NOP phi() at start of plexSort +Adding NOP phi() at start of print_cls +Adding NOP phi() at start of plexInit +Propagating live ranges... +Propagating live ranges... +Propagating live ranges... +Propagating live ranges... +Propagating live ranges... +Propagating live ranges... +Propagating live ranges... +Propagating live ranges... +Propagating live ranges... +Propagating live ranges... +Propagating live ranges... + +FINAL CONTROL FLOW GRAPH +@begin: scope:[] from + [0] phi() [ ] ( ) + to:@19 +@19: scope:[] from @begin + [1] phi() [ ] ( ) + [2] call main [ ] ( ) + to:@end +@end: scope:[] from @19 + [3] phi() [ ] ( ) +main: scope:[main] from @19 + [4] phi() [ ] ( main:2 [ ] ) + [5] call plexInit [ ] ( main:2 [ ] ) + to:main::@1 +main::@1: scope:[main] from main + [6] phi() [ ] ( main:2 [ ] ) + [7] call print_cls [ ] ( main:2 [ ] ) + to:main::@2 +main::@2: scope:[main] from main::@1 + [8] phi() [ ] ( main:2 [ ] ) + [9] call print_plex [ print_line_cursor#1 ] ( main:2 [ print_line_cursor#1 ] ) + to:main::@3 +main::@3: scope:[main] from main::@2 + [10] phi() [ print_line_cursor#1 ] ( main:2 [ print_line_cursor#1 ] ) + [11] call plexSort [ print_line_cursor#1 ] ( main:2 [ print_line_cursor#1 ] ) + to:main::@4 +main::@4: scope:[main] from main::@3 + [12] (byte*~) print_char_cursor#47 ← (byte*) print_line_cursor#1 [ print_char_cursor#47 print_line_cursor#1 ] ( main:2 [ print_char_cursor#47 print_line_cursor#1 ] ) + [13] call print_plex [ ] ( main:2 [ ] ) + to:main::@return +main::@return: scope:[main] from main::@4 + [14] return [ ] ( main:2 [ ] ) + to:@return +print_plex: scope:[print_plex] from main::@2 main::@4 + [15] (byte*) print_line_cursor#34 ← phi( main::@2/((byte*))(word/signed word/dword/signed dword) 1024 main::@4/(byte*) print_line_cursor#1 ) [ print_char_cursor#44 print_line_cursor#34 ] ( main:2::print_plex:9 [ print_char_cursor#44 print_line_cursor#34 ] main:2::print_plex:13 [ print_char_cursor#44 print_line_cursor#34 ] ) + [15] (byte*) print_char_cursor#44 ← phi( main::@2/((byte*))(word/signed word/dword/signed dword) 1024 main::@4/(byte*~) print_char_cursor#47 ) [ print_char_cursor#44 print_line_cursor#34 ] ( main:2::print_plex:9 [ print_char_cursor#44 print_line_cursor#34 ] main:2::print_plex:13 [ print_char_cursor#44 print_line_cursor#34 ] ) + to:print_plex::@1 +print_plex::@1: scope:[print_plex] from print_plex print_plex::@4 + [16] (byte*) print_char_cursor#40 ← phi( print_plex/(byte*) print_char_cursor#44 print_plex::@4/(byte*) print_char_cursor#25 ) [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 ] ) + [16] (byte) print_plex::i#2 ← phi( print_plex/(byte/signed byte/word/signed word/dword/signed dword) 0 print_plex::@4/(byte) print_plex::i#1 ) [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 ] ) + [17] (byte) print_byte::b#0 ← *((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) print_plex::i#2)) [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 ] ) + [18] call print_byte [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + to:print_plex::@3 +print_plex::@3: scope:[print_plex] from print_plex::@1 + [19] phi() [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + [20] call print_char [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + to:print_plex::@4 +print_plex::@4: scope:[print_plex] from print_plex::@3 + [21] (byte) print_plex::i#1 ← ++ (byte) print_plex::i#2 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] ) + [22] if((byte) print_plex::i#1!=(const byte) PLEX_COUNT#0-(byte/signed byte/word/signed word/dword/signed dword) 1+(byte/signed byte/word/signed word/dword/signed dword) 1) goto print_plex::@1 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] ) + to:print_plex::@2 +print_plex::@2: scope:[print_plex] from print_plex::@4 + [23] phi() [ print_line_cursor#34 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_char_cursor#25 ] ) + [24] call print_ln [ print_line_cursor#1 ] ( main:2::print_plex:9 [ print_line_cursor#1 ] main:2::print_plex:13 [ print_line_cursor#1 ] ) + to:print_plex::@return +print_plex::@return: scope:[print_plex] from print_plex::@2 + [25] return [ print_line_cursor#1 ] ( main:2::print_plex:9 [ print_line_cursor#1 ] main:2::print_plex:13 [ print_line_cursor#1 ] ) + to:@return +print_ln: scope:[print_ln] from print_plex::@2 + [26] phi() [ print_line_cursor#34 print_char_cursor#25 ] ( main:2::print_plex:9::print_ln:24 [ print_line_cursor#34 print_char_cursor#25 ] main:2::print_plex:13::print_ln:24 [ print_line_cursor#34 print_char_cursor#25 ] ) + to:print_ln::@1 +print_ln::@1: scope:[print_ln] from print_ln print_ln::@1 + [27] (byte*) print_line_cursor#12 ← phi( print_ln/(byte*) print_line_cursor#34 print_ln::@1/(byte*) print_line_cursor#1 ) [ print_char_cursor#25 print_line_cursor#12 ] ( main:2::print_plex:9::print_ln:24 [ print_char_cursor#25 print_line_cursor#12 ] main:2::print_plex:13::print_ln:24 [ print_char_cursor#25 print_line_cursor#12 ] ) + [28] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#12 + (byte/signed byte/word/signed word/dword/signed dword) 40 [ print_line_cursor#1 print_char_cursor#25 ] ( main:2::print_plex:9::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] main:2::print_plex:13::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] ) + [29] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#25) goto print_ln::@1 [ print_line_cursor#1 print_char_cursor#25 ] ( main:2::print_plex:9::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] main:2::print_plex:13::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] ) + to:print_ln::@return +print_ln::@return: scope:[print_ln] from print_ln::@1 + [30] return [ print_line_cursor#1 ] ( main:2::print_plex:9::print_ln:24 [ print_line_cursor#1 ] main:2::print_plex:13::print_ln:24 [ print_line_cursor#1 ] ) + to:@return +print_char: scope:[print_char] from print_byte print_byte::@1 print_plex::@3 + [31] (byte*) print_char_cursor#24 ← phi( print_byte/(byte*) print_char_cursor#40 print_byte::@1/(byte*) print_char_cursor#25 print_plex::@3/(byte*) print_char_cursor#25 ) [ print_char::ch#3 print_char_cursor#24 ] ( main:2::print_plex:9::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char::ch#3 print_char_cursor#24 ] main:2::print_plex:13::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char::ch#3 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char::ch#3 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char::ch#3 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char::ch#3 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char::ch#3 print_char_cursor#24 ] ) + [31] (byte) print_char::ch#3 ← phi( print_byte/(byte) print_char::ch#0 print_byte::@1/(byte) print_char::ch#1 print_plex::@3/(byte) ' ' ) [ print_char::ch#3 print_char_cursor#24 ] ( main:2::print_plex:9::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char::ch#3 print_char_cursor#24 ] main:2::print_plex:13::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char::ch#3 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char::ch#3 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char::ch#3 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char::ch#3 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char::ch#3 print_char_cursor#24 ] ) + [32] *((byte*) print_char_cursor#24) ← (byte) print_char::ch#3 [ print_char_cursor#24 ] ( main:2::print_plex:9::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] main:2::print_plex:13::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] ) + [33] (byte*) print_char_cursor#25 ← ++ (byte*) print_char_cursor#24 [ print_char_cursor#25 ] ( main:2::print_plex:9::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:9::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#25 ] main:2::print_plex:9::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + to:print_char::@return +print_char::@return: scope:[print_char] from print_char + [34] return [ print_char_cursor#25 ] ( main:2::print_plex:9::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:9::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#25 ] main:2::print_plex:9::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + to:@return +print_byte: scope:[print_byte] from print_plex::@1 + [35] (byte~) print_byte::$0 ← (byte) print_byte::b#0 >> (byte/signed byte/word/signed word/dword/signed dword) 4 [ print_char_cursor#40 print_byte::b#0 print_byte::$0 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_byte::$0 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_byte::$0 ] ) + [36] (byte) print_char::ch#0 ← *((const byte[]) print_hextab#0 + (byte~) print_byte::$0) [ print_char_cursor#40 print_byte::b#0 print_char::ch#0 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_char::ch#0 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_char::ch#0 ] ) + [37] call print_char [ print_char_cursor#25 print_byte::b#0 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::b#0 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::b#0 ] ) + to:print_byte::@1 +print_byte::@1: scope:[print_byte] from print_byte + [38] (byte~) print_byte::$2 ← (byte) print_byte::b#0 & (byte/signed byte/word/signed word/dword/signed dword) 15 [ print_char_cursor#25 print_byte::$2 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::$2 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::$2 ] ) + [39] (byte) print_char::ch#1 ← *((const byte[]) print_hextab#0 + (byte~) print_byte::$2) [ print_char_cursor#25 print_char::ch#1 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_char::ch#1 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_char::ch#1 ] ) + [40] call print_char [ print_char_cursor#25 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + to:print_byte::@return +print_byte::@return: scope:[print_byte] from print_byte::@1 + [41] return [ print_char_cursor#25 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + to:@return +plexSort: scope:[plexSort] from main::@3 + [42] phi() [ ] ( main:2::plexSort:11 [ print_line_cursor#1 ] ) + to:plexSort::@1 +plexSort::@1: scope:[plexSort] from plexSort plexSort::@2 + [43] (byte) plexSort::m#2 ← phi( plexSort/(byte/signed byte/word/signed word/dword/signed dword) 0 plexSort::@2/(byte) plexSort::m#1 ) [ plexSort::m#2 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 ] ) + [44] (byte) plexSort::nxt_idx#0 ← *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0+(byte/signed byte/word/signed word/dword/signed dword) 1 + (byte) plexSort::m#2) [ plexSort::m#2 plexSort::nxt_idx#0 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 ] ) + [45] (byte) plexSort::nxt_y#0 ← *((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + (byte) plexSort::nxt_idx#0) [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ) + [46] (byte) plexSort::cur_idx#0 ← *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::m#2) [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::cur_idx#0 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::cur_idx#0 ] ) + [47] if((byte) plexSort::nxt_y#0>=*((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + (byte) plexSort::cur_idx#0)) goto plexSort::@2 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ) + to:plexSort::@10 +plexSort::@10: scope:[plexSort] from plexSort::@1 + [48] (byte~) plexSort::s#6 ← (byte) plexSort::m#2 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#6 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#6 ] ) + to:plexSort::@3 +plexSort::@3: scope:[plexSort] from plexSort::@10 plexSort::@7 + [49] (byte) plexSort::s#3 ← phi( plexSort::@7/(byte) plexSort::s#1 plexSort::@10/(byte~) plexSort::s#6 ) [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#3 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#3 ] ) + [50] *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0+(byte/signed byte/word/signed word/dword/signed dword) 1 + (byte) plexSort::s#3) ← *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#3) [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#3 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#3 ] ) + [51] (byte) plexSort::s#1 ← -- (byte) plexSort::s#3 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ) + [52] if((byte) plexSort::s#1!=(byte/word/signed word/dword/signed dword) 255) goto plexSort::@7 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ) + to:plexSort::@5 +plexSort::@5: scope:[plexSort] from plexSort::@3 plexSort::@7 + [53] (byte) plexSort::s#2 ← ++ (byte) plexSort::s#1 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::s#2 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::s#2 ] ) + [54] *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#2) ← (byte) plexSort::nxt_idx#0 [ plexSort::m#2 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 ] ) + to:plexSort::@2 +plexSort::@2: scope:[plexSort] from plexSort::@1 plexSort::@5 + [55] (byte) plexSort::m#1 ← ++ (byte) plexSort::m#2 [ plexSort::m#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#1 ] ) + [56] if((byte) plexSort::m#1!=(const byte) PLEX_COUNT#0-(byte/signed byte/word/signed word/dword/signed dword) 2+(byte/signed byte/word/signed word/dword/signed dword) 1) goto plexSort::@1 [ plexSort::m#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#1 ] ) + to:plexSort::@return +plexSort::@return: scope:[plexSort] from plexSort::@2 + [57] return [ ] ( main:2::plexSort:11 [ print_line_cursor#1 ] ) + to:@return +plexSort::@7: scope:[plexSort] from plexSort::@3 + [58] if((byte) plexSort::nxt_y#0<*((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#1))) goto plexSort::@3 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ) + to:plexSort::@5 +print_cls: scope:[print_cls] from main::@1 + [59] phi() [ ] ( main:2::print_cls:7 [ ] ) + to:print_cls::@1 +print_cls::@1: scope:[print_cls] from print_cls print_cls::@1 + [60] (byte*) print_cls::sc#2 ← phi( print_cls/((byte*))(word/signed word/dword/signed dword) 1024 print_cls::@1/(byte*) print_cls::sc#1 ) [ print_cls::sc#2 ] ( main:2::print_cls:7 [ print_cls::sc#2 ] ) + [61] *((byte*) print_cls::sc#2) ← (byte) ' ' [ print_cls::sc#2 ] ( main:2::print_cls:7 [ print_cls::sc#2 ] ) + [62] (byte*) print_cls::sc#1 ← ++ (byte*) print_cls::sc#2 [ print_cls::sc#1 ] ( main:2::print_cls:7 [ print_cls::sc#1 ] ) + [63] if((byte*) print_cls::sc#1!=((byte*))(word/signed word/dword/signed dword) 1024+(word/signed word/dword/signed dword) 1000) goto print_cls::@1 [ print_cls::sc#1 ] ( main:2::print_cls:7 [ print_cls::sc#1 ] ) + to:print_cls::@return +print_cls::@return: scope:[print_cls] from print_cls::@1 + [64] return [ ] ( main:2::print_cls:7 [ ] ) + to:@return +plexInit: scope:[plexInit] from main + [65] phi() [ ] ( main:2::plexInit:5 [ ] ) + to:plexInit::@1 +plexInit::@1: scope:[plexInit] from plexInit plexInit::@1 + [66] (byte) plexInit::i#2 ← phi( plexInit/(byte/signed byte/word/signed word/dword/signed dword) 0 plexInit::@1/(byte) plexInit::i#1 ) [ plexInit::i#2 ] ( main:2::plexInit:5 [ plexInit::i#2 ] ) + [67] *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexInit::i#2) ← (byte) plexInit::i#2 [ plexInit::i#2 ] ( main:2::plexInit:5 [ plexInit::i#2 ] ) + [68] (byte) plexInit::i#1 ← ++ (byte) plexInit::i#2 [ plexInit::i#1 ] ( main:2::plexInit:5 [ plexInit::i#1 ] ) + [69] if((byte) plexInit::i#1!=(const byte) PLEX_COUNT#0-(byte/signed byte/word/signed word/dword/signed dword) 1+(byte/signed byte/word/signed word/dword/signed dword) 1) goto plexInit::@1 [ plexInit::i#1 ] ( main:2::plexInit:5 [ plexInit::i#1 ] ) + to:plexInit::@return +plexInit::@return: scope:[plexInit] from plexInit::@1 + [70] return [ ] ( main:2::plexInit:5 [ ] ) + to:@return + +DOMINATORS +@begin dominated by @begin +@19 dominated by @begin @19 +@end dominated by @end @begin @19 +main dominated by main @begin @19 +main::@1 dominated by main main::@1 @begin @19 +main::@2 dominated by main main::@1 main::@2 @begin @19 +main::@3 dominated by main main::@1 main::@2 main::@3 @begin @19 +main::@4 dominated by main main::@1 main::@2 main::@3 main::@4 @begin @19 +main::@return dominated by main::@return main main::@1 main::@2 main::@3 main::@4 @begin @19 +print_plex dominated by print_plex main main::@1 main::@2 @begin @19 +print_plex::@1 dominated by print_plex main print_plex::@1 main::@1 main::@2 @begin @19 +print_plex::@3 dominated by print_plex main print_plex::@1 print_plex::@3 main::@1 main::@2 @begin @19 +print_plex::@4 dominated by print_plex main print_plex::@1 print_plex::@4 print_plex::@3 main::@1 main::@2 @begin @19 +print_plex::@2 dominated by print_plex main print_plex::@2 print_plex::@1 print_plex::@4 print_plex::@3 main::@1 main::@2 @begin @19 +print_plex::@return dominated by print_plex main print_plex::@2 print_plex::@1 print_plex::@4 print_plex::@3 main::@1 main::@2 @begin @19 print_plex::@return +print_ln dominated by print_plex main print_plex::@2 print_plex::@1 print_plex::@4 print_plex::@3 main::@1 main::@2 @begin @19 print_ln +print_ln::@1 dominated by print_ln::@1 print_plex main print_plex::@2 print_plex::@1 print_plex::@4 print_plex::@3 main::@1 main::@2 @begin @19 print_ln +print_ln::@return dominated by print_ln::@1 print_plex main print_plex::@2 print_plex::@1 print_ln::@return print_plex::@4 print_plex::@3 main::@1 main::@2 @begin @19 print_ln +print_char dominated by print_plex main print_plex::@1 print_char main::@1 main::@2 @begin @19 +print_char::@return dominated by print_plex main print_plex::@1 print_char main::@1 main::@2 print_char::@return @begin @19 +print_byte dominated by print_plex main print_plex::@1 main::@1 main::@2 @begin print_byte @19 +print_byte::@1 dominated by print_plex main print_plex::@1 main::@1 main::@2 print_byte::@1 @begin print_byte @19 +print_byte::@return dominated by print_plex main print_plex::@1 main::@1 main::@2 print_byte::@1 @begin print_byte print_byte::@return @19 +plexSort dominated by main main::@1 main::@2 main::@3 @begin @19 plexSort +plexSort::@1 dominated by plexSort::@1 main main::@1 main::@2 main::@3 @begin @19 plexSort +plexSort::@10 dominated by plexSort::@1 main plexSort::@10 main::@1 main::@2 main::@3 @begin @19 plexSort +plexSort::@3 dominated by plexSort::@1 main plexSort::@10 main::@1 main::@2 main::@3 @begin @19 plexSort plexSort::@3 +plexSort::@5 dominated by plexSort::@1 main plexSort::@10 main::@1 main::@2 main::@3 @begin @19 plexSort plexSort::@3 plexSort::@5 +plexSort::@2 dominated by plexSort::@2 plexSort::@1 main main::@1 main::@2 main::@3 @begin @19 plexSort +plexSort::@return dominated by plexSort::@2 plexSort::@1 plexSort::@return main main::@1 main::@2 main::@3 @begin @19 plexSort +plexSort::@7 dominated by plexSort::@1 main plexSort::@10 main::@1 main::@2 main::@3 @begin @19 plexSort plexSort::@7 plexSort::@3 +print_cls dominated by main main::@1 @begin @19 print_cls +print_cls::@1 dominated by main main::@1 @begin @19 print_cls::@1 print_cls +print_cls::@return dominated by main main::@1 print_cls::@return @begin @19 print_cls::@1 print_cls +plexInit dominated by main @begin plexInit @19 +plexInit::@1 dominated by main plexInit::@1 @begin plexInit @19 +plexInit::@return dominated by main plexInit::@1 @begin plexInit @19 plexInit::@return + +NATURAL LOOPS +Found back edge: Loop head: print_plex::@1 tails: print_plex::@4 blocks: null +Found back edge: Loop head: print_ln::@1 tails: print_ln::@1 blocks: null +Found back edge: Loop head: plexSort::@1 tails: plexSort::@2 blocks: null +Found back edge: Loop head: plexSort::@3 tails: plexSort::@7 blocks: null +Found back edge: Loop head: print_cls::@1 tails: print_cls::@1 blocks: null +Found back edge: Loop head: plexInit::@1 tails: plexInit::@1 blocks: null +Populated: Loop head: print_plex::@1 tails: print_plex::@4 blocks: print_plex::@4 print_plex::@3 print_plex::@1 +Populated: Loop head: print_ln::@1 tails: print_ln::@1 blocks: print_ln::@1 +Populated: Loop head: plexSort::@1 tails: plexSort::@2 blocks: plexSort::@2 plexSort::@1 plexSort::@5 plexSort::@3 plexSort::@7 plexSort::@10 +Populated: Loop head: plexSort::@3 tails: plexSort::@7 blocks: plexSort::@7 plexSort::@3 +Populated: Loop head: print_cls::@1 tails: print_cls::@1 blocks: print_cls::@1 +Populated: Loop head: plexInit::@1 tails: plexInit::@1 blocks: plexInit::@1 +Loop head: print_plex::@1 tails: print_plex::@4 blocks: print_plex::@4 print_plex::@3 print_plex::@1 +Loop head: print_ln::@1 tails: print_ln::@1 blocks: print_ln::@1 +Loop head: plexSort::@1 tails: plexSort::@2 blocks: plexSort::@2 plexSort::@1 plexSort::@5 plexSort::@3 plexSort::@7 plexSort::@10 +Loop head: plexSort::@3 tails: plexSort::@7 blocks: plexSort::@7 plexSort::@3 +Loop head: print_cls::@1 tails: print_cls::@1 blocks: print_cls::@1 +Loop head: plexInit::@1 tails: plexInit::@1 blocks: plexInit::@1 + +NATURAL LOOPS WITH DEPTH +Found 0 loops in scope [] +Found 0 loops in scope [main] +Found 1 loops in scope [plexInit] + Loop head: plexInit::@1 tails: plexInit::@1 blocks: plexInit::@1 +Found 1 loops in scope [print_cls] + Loop head: print_cls::@1 tails: print_cls::@1 blocks: print_cls::@1 +Found 1 loops in scope [print_plex] + Loop head: print_plex::@1 tails: print_plex::@4 blocks: print_plex::@4 print_plex::@3 print_plex::@1 +Found 2 loops in scope [plexSort] + Loop head: plexSort::@1 tails: plexSort::@2 blocks: plexSort::@2 plexSort::@1 plexSort::@5 plexSort::@3 plexSort::@7 plexSort::@10 + Loop head: plexSort::@3 tails: plexSort::@7 blocks: plexSort::@7 plexSort::@3 +Found 0 loops in scope [print_byte] +Found 0 loops in scope [print_char] +Found 1 loops in scope [print_ln] + Loop head: print_ln::@1 tails: print_ln::@1 blocks: print_ln::@1 +Loop head: print_plex::@1 tails: print_plex::@4 blocks: print_plex::@4 print_plex::@3 print_plex::@1 depth: 1 +Loop head: print_ln::@1 tails: print_ln::@1 blocks: print_ln::@1 depth: 1 +Loop head: plexSort::@1 tails: plexSort::@2 blocks: plexSort::@2 plexSort::@1 plexSort::@5 plexSort::@3 plexSort::@7 plexSort::@10 depth: 1 +Loop head: plexSort::@3 tails: plexSort::@7 blocks: plexSort::@7 plexSort::@3 depth: 2 +Loop head: print_cls::@1 tails: print_cls::@1 blocks: print_cls::@1 depth: 1 +Loop head: plexInit::@1 tails: plexInit::@1 blocks: plexInit::@1 depth: 1 + + +VARIABLE REGISTER WEIGHTS +(byte) PLEX_COUNT +(byte[PLEX_COUNT#0]) PLEX_SORTED_IDX +(byte[PLEX_COUNT#0]) PLEX_YPOS +(void()) main() +(void()) plexInit() +(byte) plexInit::i +(byte) plexInit::i#1 16.5 +(byte) plexInit::i#2 22.0 +(void()) plexSort() +(byte) plexSort::cur_idx +(byte) plexSort::cur_idx#0 22.0 +(byte) plexSort::m +(byte) plexSort::m#1 16.5 +(byte) plexSort::m#2 4.230769230769231 +(byte) plexSort::nxt_idx +(byte) plexSort::nxt_idx#0 3.0 +(byte) plexSort::nxt_y +(byte) plexSort::nxt_y#0 13.666666666666666 +(byte) plexSort::s +(byte) plexSort::s#1 138.33333333333334 +(byte) plexSort::s#2 22.0 +(byte) plexSort::s#3 207.5 +(byte~) plexSort::s#6 22.0 +(void()) print_byte((byte) print_byte::b) +(byte~) print_byte::$0 4.0 +(byte~) print_byte::$2 4.0 +(byte) print_byte::b +(byte) print_byte::b#0 3.75 +(void()) print_char((byte) print_char::ch) +(byte) print_char::ch +(byte) print_char::ch#0 4.0 +(byte) print_char::ch#1 4.0 +(byte) print_char::ch#3 6.0 +(byte*) print_char_cursor +(byte*) print_char_cursor#24 9.5 +(byte*) print_char_cursor#25 2.1764705882352944 +(byte*) print_char_cursor#40 3.75 +(byte*) print_char_cursor#44 4.0 +(byte*~) print_char_cursor#47 4.0 +(void()) print_cls() +(byte*) print_cls::sc +(byte*) print_cls::sc#1 16.5 +(byte*) print_cls::sc#2 16.5 +(byte[]) print_hextab +(byte*) print_line_cursor +(byte*) print_line_cursor#1 4.111111111111112 +(byte*) print_line_cursor#12 24.0 +(byte*) print_line_cursor#34 0.4 +(void()) print_ln() +(void()) print_plex() +(byte) print_plex::i +(byte) print_plex::i#1 16.5 +(byte) print_plex::i#2 6.6000000000000005 +(byte*) print_screen + +Initial phi equivalence classes +[ print_plex::i#2 print_plex::i#1 ] +[ print_line_cursor#12 print_line_cursor#34 print_line_cursor#1 ] +[ print_char::ch#3 print_char::ch#0 print_char::ch#1 ] +[ print_char_cursor#24 print_char_cursor#40 print_char_cursor#44 print_char_cursor#47 print_char_cursor#25 ] +[ plexSort::m#2 plexSort::m#1 ] +[ plexSort::s#3 plexSort::s#1 plexSort::s#6 ] +[ print_cls::sc#2 print_cls::sc#1 ] +[ plexInit::i#2 plexInit::i#1 ] +Added variable print_byte::b#0 to zero page equivalence class [ print_byte::b#0 ] +Added variable print_byte::$0 to zero page equivalence class [ print_byte::$0 ] +Added variable print_byte::$2 to zero page equivalence class [ print_byte::$2 ] +Added variable plexSort::nxt_idx#0 to zero page equivalence class [ plexSort::nxt_idx#0 ] +Added variable plexSort::nxt_y#0 to zero page equivalence class [ plexSort::nxt_y#0 ] +Added variable plexSort::cur_idx#0 to zero page equivalence class [ plexSort::cur_idx#0 ] +Added variable plexSort::s#2 to zero page equivalence class [ plexSort::s#2 ] +Complete equivalence classes +[ print_plex::i#2 print_plex::i#1 ] +[ print_line_cursor#12 print_line_cursor#34 print_line_cursor#1 ] +[ print_char::ch#3 print_char::ch#0 print_char::ch#1 ] +[ print_char_cursor#24 print_char_cursor#40 print_char_cursor#44 print_char_cursor#47 print_char_cursor#25 ] +[ plexSort::m#2 plexSort::m#1 ] +[ plexSort::s#3 plexSort::s#1 plexSort::s#6 ] +[ print_cls::sc#2 print_cls::sc#1 ] +[ plexInit::i#2 plexInit::i#1 ] +[ print_byte::b#0 ] +[ print_byte::$0 ] +[ print_byte::$2 ] +[ plexSort::nxt_idx#0 ] +[ plexSort::nxt_y#0 ] +[ plexSort::cur_idx#0 ] +[ plexSort::s#2 ] +Allocated zp ZP_BYTE:2 [ print_plex::i#2 print_plex::i#1 ] +Allocated zp ZP_WORD:3 [ print_line_cursor#12 print_line_cursor#34 print_line_cursor#1 ] +Allocated zp ZP_BYTE:5 [ print_char::ch#3 print_char::ch#0 print_char::ch#1 ] +Allocated zp ZP_WORD:6 [ print_char_cursor#24 print_char_cursor#40 print_char_cursor#44 print_char_cursor#47 print_char_cursor#25 ] +Allocated zp ZP_BYTE:8 [ plexSort::m#2 plexSort::m#1 ] +Allocated zp ZP_BYTE:9 [ plexSort::s#3 plexSort::s#1 plexSort::s#6 ] +Allocated zp ZP_WORD:10 [ print_cls::sc#2 print_cls::sc#1 ] +Allocated zp ZP_BYTE:12 [ plexInit::i#2 plexInit::i#1 ] +Allocated zp ZP_BYTE:13 [ print_byte::b#0 ] +Allocated zp ZP_BYTE:14 [ print_byte::$0 ] +Allocated zp ZP_BYTE:15 [ print_byte::$2 ] +Allocated zp ZP_BYTE:16 [ plexSort::nxt_idx#0 ] +Allocated zp ZP_BYTE:17 [ plexSort::nxt_y#0 ] +Allocated zp ZP_BYTE:18 [ plexSort::cur_idx#0 ] +Allocated zp ZP_BYTE:19 [ plexSort::s#2 ] + +INITIAL ASM +//SEG0 Basic Upstart +.pc = $801 "Basic" +:BasicUpstart(main) +.pc = $80d "Program" +//SEG1 Global Constants & labels + .const PLEX_COUNT = $a + .label print_line_cursor = 3 + .label print_char_cursor = 6 +//SEG2 @begin +bbegin: +//SEG3 [1] phi from @begin to @19 [phi:@begin->@19] +b19_from_bbegin: + jmp b19 +//SEG4 @19 +b19: +//SEG5 [2] call main [ ] ( ) +//SEG6 [4] phi from @19 to main [phi:@19->main] +main_from_b19: + jsr main +//SEG7 [3] phi from @19 to @end [phi:@19->@end] +bend_from_b19: + jmp bend +//SEG8 @end +bend: +//SEG9 main +main: { + //SEG10 [5] call plexInit [ ] ( main:2 [ ] ) + //SEG11 [65] phi from main to plexInit [phi:main->plexInit] + plexInit_from_main: + jsr plexInit + //SEG12 [6] phi from main to main::@1 [phi:main->main::@1] + b1_from_main: + jmp b1 + //SEG13 main::@1 + b1: + //SEG14 [7] call print_cls [ ] ( main:2 [ ] ) + //SEG15 [59] phi from main::@1 to print_cls [phi:main::@1->print_cls] + print_cls_from_b1: + jsr print_cls + //SEG16 [8] phi from main::@1 to main::@2 [phi:main::@1->main::@2] + b2_from_b1: + jmp b2 + //SEG17 main::@2 + b2: + //SEG18 [9] call print_plex [ print_line_cursor#1 ] ( main:2 [ print_line_cursor#1 ] ) + //SEG19 [15] phi from main::@2 to print_plex [phi:main::@2->print_plex] + print_plex_from_b2: + //SEG20 [15] phi (byte*) print_line_cursor#34 = ((byte*))(word/signed word/dword/signed dword) 1024 [phi:main::@2->print_plex#0] -- pbuz1=pbuc1 + lda #<$400 + sta print_line_cursor + lda #>$400 + sta print_line_cursor+1 + //SEG21 [15] phi (byte*) print_char_cursor#44 = ((byte*))(word/signed word/dword/signed dword) 1024 [phi:main::@2->print_plex#1] -- pbuz1=pbuc1 + lda #<$400 + sta print_char_cursor + lda #>$400 + sta print_char_cursor+1 + jsr print_plex + //SEG22 [10] phi from main::@2 to main::@3 [phi:main::@2->main::@3] + b3_from_b2: + jmp b3 + //SEG23 main::@3 + b3: + //SEG24 [11] call plexSort [ print_line_cursor#1 ] ( main:2 [ print_line_cursor#1 ] ) + //SEG25 [42] phi from main::@3 to plexSort [phi:main::@3->plexSort] + plexSort_from_b3: + jsr plexSort + jmp b4 + //SEG26 main::@4 + b4: + //SEG27 [12] (byte*~) print_char_cursor#47 ← (byte*) print_line_cursor#1 [ print_char_cursor#47 print_line_cursor#1 ] ( main:2 [ print_char_cursor#47 print_line_cursor#1 ] ) -- pbuz1=pbuz2 + lda print_line_cursor + sta print_char_cursor + lda print_line_cursor+1 + sta print_char_cursor+1 + //SEG28 [13] call print_plex [ ] ( main:2 [ ] ) + //SEG29 [15] phi from main::@4 to print_plex [phi:main::@4->print_plex] + print_plex_from_b4: + //SEG30 [15] phi (byte*) print_line_cursor#34 = (byte*) print_line_cursor#1 [phi:main::@4->print_plex#0] -- register_copy + //SEG31 [15] phi (byte*) print_char_cursor#44 = (byte*~) print_char_cursor#47 [phi:main::@4->print_plex#1] -- register_copy + jsr print_plex + jmp breturn + //SEG32 main::@return + breturn: + //SEG33 [14] return [ ] ( main:2 [ ] ) + rts +} +//SEG34 print_plex +print_plex: { + .label i = 2 + //SEG35 [16] phi from print_plex to print_plex::@1 [phi:print_plex->print_plex::@1] + b1_from_print_plex: + //SEG36 [16] phi (byte*) print_char_cursor#40 = (byte*) print_char_cursor#44 [phi:print_plex->print_plex::@1#0] -- register_copy + //SEG37 [16] phi (byte) print_plex::i#2 = (byte/signed byte/word/signed word/dword/signed dword) 0 [phi:print_plex->print_plex::@1#1] -- vbuz1=vbuc1 + lda #0 + sta i + jmp b1 + //SEG38 [16] phi from print_plex::@4 to print_plex::@1 [phi:print_plex::@4->print_plex::@1] + b1_from_b4: + //SEG39 [16] phi (byte*) print_char_cursor#40 = (byte*) print_char_cursor#25 [phi:print_plex::@4->print_plex::@1#0] -- register_copy + //SEG40 [16] phi (byte) print_plex::i#2 = (byte) print_plex::i#1 [phi:print_plex::@4->print_plex::@1#1] -- register_copy + jmp b1 + //SEG41 print_plex::@1 + b1: + //SEG42 [17] (byte) print_byte::b#0 ← *((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) print_plex::i#2)) [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 ] ) -- vbuz1=pbuc1_derefidx_pbuc2_derefidx_vbuz2 + ldy i + lda PLEX_SORTED_IDX,y + tay + lda PLEX_YPOS,y + sta print_byte.b + //SEG43 [18] call print_byte [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + jsr print_byte + //SEG44 [19] phi from print_plex::@1 to print_plex::@3 [phi:print_plex::@1->print_plex::@3] + b3_from_b1: + jmp b3 + //SEG45 print_plex::@3 + b3: + //SEG46 [20] call print_char [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + //SEG47 [31] phi from print_plex::@3 to print_char [phi:print_plex::@3->print_char] + print_char_from_b3: + //SEG48 [31] phi (byte*) print_char_cursor#24 = (byte*) print_char_cursor#25 [phi:print_plex::@3->print_char#0] -- register_copy + //SEG49 [31] phi (byte) print_char::ch#3 = (byte) ' ' [phi:print_plex::@3->print_char#1] -- vbuz1=vbuc1 + lda #' ' + sta print_char.ch + jsr print_char + jmp b4 + //SEG50 print_plex::@4 + b4: + //SEG51 [21] (byte) print_plex::i#1 ← ++ (byte) print_plex::i#2 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] ) -- vbuz1=_inc_vbuz1 + inc i + //SEG52 [22] if((byte) print_plex::i#1!=(const byte) PLEX_COUNT#0-(byte/signed byte/word/signed word/dword/signed dword) 1+(byte/signed byte/word/signed word/dword/signed dword) 1) goto print_plex::@1 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] ) -- vbuz1_neq_vbuc1_then_la1 + lda i + cmp #PLEX_COUNT-1+1 + bne b1_from_b4 + //SEG53 [23] phi from print_plex::@4 to print_plex::@2 [phi:print_plex::@4->print_plex::@2] + b2_from_b4: + jmp b2 + //SEG54 print_plex::@2 + b2: + //SEG55 [24] call print_ln [ print_line_cursor#1 ] ( main:2::print_plex:9 [ print_line_cursor#1 ] main:2::print_plex:13 [ print_line_cursor#1 ] ) + //SEG56 [26] phi from print_plex::@2 to print_ln [phi:print_plex::@2->print_ln] + print_ln_from_b2: + jsr print_ln + jmp breturn + //SEG57 print_plex::@return + breturn: + //SEG58 [25] return [ print_line_cursor#1 ] ( main:2::print_plex:9 [ print_line_cursor#1 ] main:2::print_plex:13 [ print_line_cursor#1 ] ) + rts +} +//SEG59 print_ln +print_ln: { + //SEG60 [27] phi from print_ln print_ln::@1 to print_ln::@1 [phi:print_ln/print_ln::@1->print_ln::@1] + b1_from_print_ln: + b1_from_b1: + //SEG61 [27] phi (byte*) print_line_cursor#12 = (byte*) print_line_cursor#34 [phi:print_ln/print_ln::@1->print_ln::@1#0] -- register_copy + jmp b1 + //SEG62 print_ln::@1 + b1: + //SEG63 [28] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#12 + (byte/signed byte/word/signed word/dword/signed dword) 40 [ print_line_cursor#1 print_char_cursor#25 ] ( main:2::print_plex:9::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] main:2::print_plex:13::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] ) -- pbuz1=pbuz1_plus_vbuc1 + lda print_line_cursor + clc + adc #$28 + sta print_line_cursor + bcc !+ + inc print_line_cursor+1 + !: + //SEG64 [29] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#25) goto print_ln::@1 [ print_line_cursor#1 print_char_cursor#25 ] ( main:2::print_plex:9::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] main:2::print_plex:13::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] ) -- pbuz1_lt_pbuz2_then_la1 + lda print_line_cursor+1 + cmp print_char_cursor+1 + bcc b1_from_b1 + bne !+ + lda print_line_cursor + cmp print_char_cursor + bcc b1_from_b1 + !: + jmp breturn + //SEG65 print_ln::@return + breturn: + //SEG66 [30] return [ print_line_cursor#1 ] ( main:2::print_plex:9::print_ln:24 [ print_line_cursor#1 ] main:2::print_plex:13::print_ln:24 [ print_line_cursor#1 ] ) + rts +} +//SEG67 print_char +print_char: { + .label ch = 5 + //SEG68 [32] *((byte*) print_char_cursor#24) ← (byte) print_char::ch#3 [ print_char_cursor#24 ] ( main:2::print_plex:9::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] main:2::print_plex:13::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] ) -- _deref_pbuz1=vbuz2 + lda ch + ldy #0 + sta (print_char_cursor),y + //SEG69 [33] (byte*) print_char_cursor#25 ← ++ (byte*) print_char_cursor#24 [ print_char_cursor#25 ] ( main:2::print_plex:9::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:9::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#25 ] main:2::print_plex:9::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) -- pbuz1=_inc_pbuz1 + inc print_char_cursor + bne !+ + inc print_char_cursor+1 + !: + jmp breturn + //SEG70 print_char::@return + breturn: + //SEG71 [34] return [ print_char_cursor#25 ] ( main:2::print_plex:9::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:9::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#25 ] main:2::print_plex:9::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + rts +} +//SEG72 print_byte +print_byte: { + .label _0 = $e + .label _2 = $f + .label b = $d + //SEG73 [35] (byte~) print_byte::$0 ← (byte) print_byte::b#0 >> (byte/signed byte/word/signed word/dword/signed dword) 4 [ print_char_cursor#40 print_byte::b#0 print_byte::$0 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_byte::$0 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_byte::$0 ] ) -- vbuz1=vbuz2_ror_4 + lda b + lsr + lsr + lsr + lsr + sta _0 + //SEG74 [36] (byte) print_char::ch#0 ← *((const byte[]) print_hextab#0 + (byte~) print_byte::$0) [ print_char_cursor#40 print_byte::b#0 print_char::ch#0 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_char::ch#0 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_char::ch#0 ] ) -- vbuz1=pbuc1_derefidx_vbuz2 + ldy _0 + lda print_hextab,y + sta print_char.ch + //SEG75 [37] call print_char [ print_char_cursor#25 print_byte::b#0 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::b#0 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::b#0 ] ) + //SEG76 [31] phi from print_byte to print_char [phi:print_byte->print_char] + print_char_from_print_byte: + //SEG77 [31] phi (byte*) print_char_cursor#24 = (byte*) print_char_cursor#40 [phi:print_byte->print_char#0] -- register_copy + //SEG78 [31] phi (byte) print_char::ch#3 = (byte) print_char::ch#0 [phi:print_byte->print_char#1] -- register_copy + jsr print_char + jmp b1 + //SEG79 print_byte::@1 + b1: + //SEG80 [38] (byte~) print_byte::$2 ← (byte) print_byte::b#0 & (byte/signed byte/word/signed word/dword/signed dword) 15 [ print_char_cursor#25 print_byte::$2 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::$2 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::$2 ] ) -- vbuz1=vbuz2_band_vbuc1 + lda #$f + and b + sta _2 + //SEG81 [39] (byte) print_char::ch#1 ← *((const byte[]) print_hextab#0 + (byte~) print_byte::$2) [ print_char_cursor#25 print_char::ch#1 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_char::ch#1 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_char::ch#1 ] ) -- vbuz1=pbuc1_derefidx_vbuz2 + ldy _2 + lda print_hextab,y + sta print_char.ch + //SEG82 [40] call print_char [ print_char_cursor#25 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + //SEG83 [31] phi from print_byte::@1 to print_char [phi:print_byte::@1->print_char] + print_char_from_b1: + //SEG84 [31] phi (byte*) print_char_cursor#24 = (byte*) print_char_cursor#25 [phi:print_byte::@1->print_char#0] -- register_copy + //SEG85 [31] phi (byte) print_char::ch#3 = (byte) print_char::ch#1 [phi:print_byte::@1->print_char#1] -- register_copy + jsr print_char + jmp breturn + //SEG86 print_byte::@return + breturn: + //SEG87 [41] return [ print_char_cursor#25 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + rts +} +//SEG88 plexSort +plexSort: { + .label nxt_idx = $10 + .label nxt_y = $11 + .label cur_idx = $12 + .label m = 8 + .label s = 9 + .label s_2 = $13 + //SEG89 [43] phi from plexSort to plexSort::@1 [phi:plexSort->plexSort::@1] + b1_from_plexSort: + //SEG90 [43] phi (byte) plexSort::m#2 = (byte/signed byte/word/signed word/dword/signed dword) 0 [phi:plexSort->plexSort::@1#0] -- vbuz1=vbuc1 + lda #0 + sta m + jmp b1 + //SEG91 [43] phi from plexSort::@2 to plexSort::@1 [phi:plexSort::@2->plexSort::@1] + b1_from_b2: + //SEG92 [43] phi (byte) plexSort::m#2 = (byte) plexSort::m#1 [phi:plexSort::@2->plexSort::@1#0] -- register_copy + jmp b1 + //SEG93 plexSort::@1 + b1: + //SEG94 [44] (byte) plexSort::nxt_idx#0 ← *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0+(byte/signed byte/word/signed word/dword/signed dword) 1 + (byte) plexSort::m#2) [ plexSort::m#2 plexSort::nxt_idx#0 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 ] ) -- vbuz1=pbuc1_derefidx_vbuz2 + ldy m + lda PLEX_SORTED_IDX+1,y + sta nxt_idx + //SEG95 [45] (byte) plexSort::nxt_y#0 ← *((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + (byte) plexSort::nxt_idx#0) [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ) -- vbuz1=pbuc1_derefidx_vbuz2 + ldy nxt_idx + lda PLEX_YPOS,y + sta nxt_y + //SEG96 [46] (byte) plexSort::cur_idx#0 ← *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::m#2) [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::cur_idx#0 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::cur_idx#0 ] ) -- vbuz1=pbuc1_derefidx_vbuz2 + ldy m + lda PLEX_SORTED_IDX,y + sta cur_idx + //SEG97 [47] if((byte) plexSort::nxt_y#0>=*((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + (byte) plexSort::cur_idx#0)) goto plexSort::@2 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ) -- vbuz1_ge_pbuc1_derefidx_vbuz2_then_la1 + lda nxt_y + ldy cur_idx + cmp PLEX_YPOS,y + bcs b2 + jmp b10 + //SEG98 plexSort::@10 + b10: + //SEG99 [48] (byte~) plexSort::s#6 ← (byte) plexSort::m#2 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#6 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#6 ] ) -- vbuz1=vbuz2 + lda m + sta s + //SEG100 [49] phi from plexSort::@10 plexSort::@7 to plexSort::@3 [phi:plexSort::@10/plexSort::@7->plexSort::@3] + b3_from_b10: + b3_from_b7: + //SEG101 [49] phi (byte) plexSort::s#3 = (byte~) plexSort::s#6 [phi:plexSort::@10/plexSort::@7->plexSort::@3#0] -- register_copy + jmp b3 + //SEG102 plexSort::@3 + b3: + //SEG103 [50] *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0+(byte/signed byte/word/signed word/dword/signed dword) 1 + (byte) plexSort::s#3) ← *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#3) [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#3 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#3 ] ) -- pbuc1_derefidx_vbuz1=pbuc2_derefidx_vbuz1 + ldy s + lda PLEX_SORTED_IDX,y + sta PLEX_SORTED_IDX+1,y + //SEG104 [51] (byte) plexSort::s#1 ← -- (byte) plexSort::s#3 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ) -- vbuz1=_dec_vbuz1 + dec s + //SEG105 [52] if((byte) plexSort::s#1!=(byte/word/signed word/dword/signed dword) 255) goto plexSort::@7 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ) -- vbuz1_neq_vbuc1_then_la1 + lda s + cmp #$ff + bne b7 + jmp b5 + //SEG106 plexSort::@5 + b5: + //SEG107 [53] (byte) plexSort::s#2 ← ++ (byte) plexSort::s#1 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::s#2 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::s#2 ] ) -- vbuz1=_inc_vbuz2 + ldy s + iny + sty s_2 + //SEG108 [54] *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#2) ← (byte) plexSort::nxt_idx#0 [ plexSort::m#2 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 ] ) -- pbuc1_derefidx_vbuz1=vbuz2 + lda nxt_idx + ldy s_2 + sta PLEX_SORTED_IDX,y + jmp b2 + //SEG109 plexSort::@2 + b2: + //SEG110 [55] (byte) plexSort::m#1 ← ++ (byte) plexSort::m#2 [ plexSort::m#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#1 ] ) -- vbuz1=_inc_vbuz1 + inc m + //SEG111 [56] if((byte) plexSort::m#1!=(const byte) PLEX_COUNT#0-(byte/signed byte/word/signed word/dword/signed dword) 2+(byte/signed byte/word/signed word/dword/signed dword) 1) goto plexSort::@1 [ plexSort::m#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#1 ] ) -- vbuz1_neq_vbuc1_then_la1 + lda m + cmp #PLEX_COUNT-2+1 + bne b1_from_b2 + jmp breturn + //SEG112 plexSort::@return + breturn: + //SEG113 [57] return [ ] ( main:2::plexSort:11 [ print_line_cursor#1 ] ) + rts + //SEG114 plexSort::@7 + b7: + //SEG115 [58] if((byte) plexSort::nxt_y#0<*((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#1))) goto plexSort::@3 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ) -- vbuz1_lt_pbuc1_derefidx_pbuc2_derefidx_vbuz2_then_la1 + lda nxt_y + ldx s + ldy PLEX_SORTED_IDX,x + cmp PLEX_YPOS,y + bcc b3_from_b7 + jmp b5 +} +//SEG116 print_cls +print_cls: { + .label sc = $a + //SEG117 [60] phi from print_cls to print_cls::@1 [phi:print_cls->print_cls::@1] + b1_from_print_cls: + //SEG118 [60] phi (byte*) print_cls::sc#2 = ((byte*))(word/signed word/dword/signed dword) 1024 [phi:print_cls->print_cls::@1#0] -- pbuz1=pbuc1 + lda #<$400 + sta sc + lda #>$400 + sta sc+1 + jmp b1 + //SEG119 [60] phi from print_cls::@1 to print_cls::@1 [phi:print_cls::@1->print_cls::@1] + b1_from_b1: + //SEG120 [60] phi (byte*) print_cls::sc#2 = (byte*) print_cls::sc#1 [phi:print_cls::@1->print_cls::@1#0] -- register_copy + jmp b1 + //SEG121 print_cls::@1 + b1: + //SEG122 [61] *((byte*) print_cls::sc#2) ← (byte) ' ' [ print_cls::sc#2 ] ( main:2::print_cls:7 [ print_cls::sc#2 ] ) -- _deref_pbuz1=vbuc1 + lda #' ' + ldy #0 + sta (sc),y + //SEG123 [62] (byte*) print_cls::sc#1 ← ++ (byte*) print_cls::sc#2 [ print_cls::sc#1 ] ( main:2::print_cls:7 [ print_cls::sc#1 ] ) -- pbuz1=_inc_pbuz1 + inc sc + bne !+ + inc sc+1 + !: + //SEG124 [63] if((byte*) print_cls::sc#1!=((byte*))(word/signed word/dword/signed dword) 1024+(word/signed word/dword/signed dword) 1000) goto print_cls::@1 [ print_cls::sc#1 ] ( main:2::print_cls:7 [ print_cls::sc#1 ] ) -- pbuz1_neq_pbuc1_then_la1 + lda sc+1 + cmp #>$400+$3e8 + bne b1_from_b1 + lda sc + cmp #<$400+$3e8 + bne b1_from_b1 + jmp breturn + //SEG125 print_cls::@return + breturn: + //SEG126 [64] return [ ] ( main:2::print_cls:7 [ ] ) + rts +} +//SEG127 plexInit +plexInit: { + .label i = $c + //SEG128 [66] phi from plexInit to plexInit::@1 [phi:plexInit->plexInit::@1] + b1_from_plexInit: + //SEG129 [66] phi (byte) plexInit::i#2 = (byte/signed byte/word/signed word/dword/signed dword) 0 [phi:plexInit->plexInit::@1#0] -- vbuz1=vbuc1 + lda #0 + sta i + jmp b1 + //SEG130 [66] phi from plexInit::@1 to plexInit::@1 [phi:plexInit::@1->plexInit::@1] + b1_from_b1: + //SEG131 [66] phi (byte) plexInit::i#2 = (byte) plexInit::i#1 [phi:plexInit::@1->plexInit::@1#0] -- register_copy + jmp b1 + //SEG132 plexInit::@1 + b1: + //SEG133 [67] *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexInit::i#2) ← (byte) plexInit::i#2 [ plexInit::i#2 ] ( main:2::plexInit:5 [ plexInit::i#2 ] ) -- pbuc1_derefidx_vbuz1=vbuz1 + ldy i + tya + sta PLEX_SORTED_IDX,y + //SEG134 [68] (byte) plexInit::i#1 ← ++ (byte) plexInit::i#2 [ plexInit::i#1 ] ( main:2::plexInit:5 [ plexInit::i#1 ] ) -- vbuz1=_inc_vbuz1 + inc i + //SEG135 [69] if((byte) plexInit::i#1!=(const byte) PLEX_COUNT#0-(byte/signed byte/word/signed word/dword/signed dword) 1+(byte/signed byte/word/signed word/dword/signed dword) 1) goto plexInit::@1 [ plexInit::i#1 ] ( main:2::plexInit:5 [ plexInit::i#1 ] ) -- vbuz1_neq_vbuc1_then_la1 + lda i + cmp #PLEX_COUNT-1+1 + bne b1_from_b1 + jmp breturn + //SEG136 plexInit::@return + breturn: + //SEG137 [70] return [ ] ( main:2::plexInit:5 [ ] ) + rts +} + print_hextab: .text "0123456789abcdef" + PLEX_YPOS: .byte $ff, $12, $11, $34, 2, $81, $77, $81, $ef, $11 + PLEX_SORTED_IDX: .fill PLEX_COUNT, 0 + +REGISTER UPLIFT POTENTIAL REGISTERS +Statement [12] (byte*~) print_char_cursor#47 ← (byte*) print_line_cursor#1 [ print_char_cursor#47 print_line_cursor#1 ] ( main:2 [ print_char_cursor#47 print_line_cursor#1 ] ) always clobbers reg byte a +Statement [17] (byte) print_byte::b#0 ← *((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) print_plex::i#2)) [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp ZP_BYTE:2 [ print_plex::i#2 print_plex::i#1 ] +Statement [28] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#12 + (byte/signed byte/word/signed word/dword/signed dword) 40 [ print_line_cursor#1 print_char_cursor#25 ] ( main:2::print_plex:9::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] main:2::print_plex:13::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] ) always clobbers reg byte a +Statement [29] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#25) goto print_ln::@1 [ print_line_cursor#1 print_char_cursor#25 ] ( main:2::print_plex:9::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] main:2::print_plex:13::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] ) always clobbers reg byte a +Statement [32] *((byte*) print_char_cursor#24) ← (byte) print_char::ch#3 [ print_char_cursor#24 ] ( main:2::print_plex:9::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] main:2::print_plex:13::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] ) always clobbers reg byte y +Removing always clobbered register reg byte y as potential for zp ZP_BYTE:2 [ print_plex::i#2 print_plex::i#1 ] +Removing always clobbered register reg byte y as potential for zp ZP_BYTE:13 [ print_byte::b#0 ] +Statement [35] (byte~) print_byte::$0 ← (byte) print_byte::b#0 >> (byte/signed byte/word/signed word/dword/signed dword) 4 [ print_char_cursor#40 print_byte::b#0 print_byte::$0 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_byte::$0 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_byte::$0 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp ZP_BYTE:13 [ print_byte::b#0 ] +Statement [38] (byte~) print_byte::$2 ← (byte) print_byte::b#0 & (byte/signed byte/word/signed word/dword/signed dword) 15 [ print_char_cursor#25 print_byte::$2 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::$2 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::$2 ] ) always clobbers reg byte a +Statement [50] *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0+(byte/signed byte/word/signed word/dword/signed dword) 1 + (byte) plexSort::s#3) ← *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#3) [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#3 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#3 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp ZP_BYTE:8 [ plexSort::m#2 plexSort::m#1 ] +Removing always clobbered register reg byte a as potential for zp ZP_BYTE:16 [ plexSort::nxt_idx#0 ] +Removing always clobbered register reg byte a as potential for zp ZP_BYTE:17 [ plexSort::nxt_y#0 ] +Removing always clobbered register reg byte a as potential for zp ZP_BYTE:9 [ plexSort::s#3 plexSort::s#1 plexSort::s#6 ] +Statement [54] *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#2) ← (byte) plexSort::nxt_idx#0 [ plexSort::m#2 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 ] ) always clobbers reg byte a +Statement [58] if((byte) plexSort::nxt_y#0<*((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#1))) goto plexSort::@3 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ) always clobbers reg byte a +Statement [61] *((byte*) print_cls::sc#2) ← (byte) ' ' [ print_cls::sc#2 ] ( main:2::print_cls:7 [ print_cls::sc#2 ] ) always clobbers reg byte a reg byte y +Statement [63] if((byte*) print_cls::sc#1!=((byte*))(word/signed word/dword/signed dword) 1024+(word/signed word/dword/signed dword) 1000) goto print_cls::@1 [ print_cls::sc#1 ] ( main:2::print_cls:7 [ print_cls::sc#1 ] ) always clobbers reg byte a +Statement [12] (byte*~) print_char_cursor#47 ← (byte*) print_line_cursor#1 [ print_char_cursor#47 print_line_cursor#1 ] ( main:2 [ print_char_cursor#47 print_line_cursor#1 ] ) always clobbers reg byte a +Statement [17] (byte) print_byte::b#0 ← *((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) print_plex::i#2)) [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 ] ) always clobbers reg byte a +Statement [28] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#12 + (byte/signed byte/word/signed word/dword/signed dword) 40 [ print_line_cursor#1 print_char_cursor#25 ] ( main:2::print_plex:9::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] main:2::print_plex:13::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] ) always clobbers reg byte a +Statement [29] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#25) goto print_ln::@1 [ print_line_cursor#1 print_char_cursor#25 ] ( main:2::print_plex:9::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] main:2::print_plex:13::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] ) always clobbers reg byte a +Statement [32] *((byte*) print_char_cursor#24) ← (byte) print_char::ch#3 [ print_char_cursor#24 ] ( main:2::print_plex:9::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] main:2::print_plex:13::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] ) always clobbers reg byte y +Statement [35] (byte~) print_byte::$0 ← (byte) print_byte::b#0 >> (byte/signed byte/word/signed word/dword/signed dword) 4 [ print_char_cursor#40 print_byte::b#0 print_byte::$0 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_byte::$0 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_byte::$0 ] ) always clobbers reg byte a +Statement [38] (byte~) print_byte::$2 ← (byte) print_byte::b#0 & (byte/signed byte/word/signed word/dword/signed dword) 15 [ print_char_cursor#25 print_byte::$2 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::$2 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::$2 ] ) always clobbers reg byte a +Statement [47] if((byte) plexSort::nxt_y#0>=*((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + (byte) plexSort::cur_idx#0)) goto plexSort::@2 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ) always clobbers reg byte a +Statement [50] *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0+(byte/signed byte/word/signed word/dword/signed dword) 1 + (byte) plexSort::s#3) ← *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#3) [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#3 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#3 ] ) always clobbers reg byte a +Statement [54] *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#2) ← (byte) plexSort::nxt_idx#0 [ plexSort::m#2 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 ] ) always clobbers reg byte a +Statement [58] if((byte) plexSort::nxt_y#0<*((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#1))) goto plexSort::@3 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ) always clobbers reg byte a +Statement [61] *((byte*) print_cls::sc#2) ← (byte) ' ' [ print_cls::sc#2 ] ( main:2::print_cls:7 [ print_cls::sc#2 ] ) always clobbers reg byte a reg byte y +Statement [63] if((byte*) print_cls::sc#1!=((byte*))(word/signed word/dword/signed dword) 1024+(word/signed word/dword/signed dword) 1000) goto print_cls::@1 [ print_cls::sc#1 ] ( main:2::print_cls:7 [ print_cls::sc#1 ] ) always clobbers reg byte a +Potential registers zp ZP_BYTE:2 [ print_plex::i#2 print_plex::i#1 ] : zp ZP_BYTE:2 , reg byte x , +Potential registers zp ZP_WORD:3 [ print_line_cursor#12 print_line_cursor#34 print_line_cursor#1 ] : zp ZP_WORD:3 , +Potential registers zp ZP_BYTE:5 [ print_char::ch#3 print_char::ch#0 print_char::ch#1 ] : zp ZP_BYTE:5 , reg byte a , reg byte x , reg byte y , +Potential registers zp ZP_WORD:6 [ print_char_cursor#24 print_char_cursor#40 print_char_cursor#44 print_char_cursor#47 print_char_cursor#25 ] : zp ZP_WORD:6 , +Potential registers zp ZP_BYTE:8 [ plexSort::m#2 plexSort::m#1 ] : zp ZP_BYTE:8 , reg byte x , reg byte y , +Potential registers zp ZP_BYTE:9 [ plexSort::s#3 plexSort::s#1 plexSort::s#6 ] : zp ZP_BYTE:9 , reg byte x , reg byte y , +Potential registers zp ZP_WORD:10 [ print_cls::sc#2 print_cls::sc#1 ] : zp ZP_WORD:10 , +Potential registers zp ZP_BYTE:12 [ plexInit::i#2 plexInit::i#1 ] : zp ZP_BYTE:12 , reg byte a , reg byte x , reg byte y , +Potential registers zp ZP_BYTE:13 [ print_byte::b#0 ] : zp ZP_BYTE:13 , reg byte x , +Potential registers zp ZP_BYTE:14 [ print_byte::$0 ] : zp ZP_BYTE:14 , reg byte a , reg byte x , reg byte y , +Potential registers zp ZP_BYTE:15 [ print_byte::$2 ] : zp ZP_BYTE:15 , reg byte a , reg byte x , reg byte y , +Potential registers zp ZP_BYTE:16 [ plexSort::nxt_idx#0 ] : zp ZP_BYTE:16 , reg byte x , reg byte y , +Potential registers zp ZP_BYTE:17 [ plexSort::nxt_y#0 ] : zp ZP_BYTE:17 , reg byte x , reg byte y , +Potential registers zp ZP_BYTE:18 [ plexSort::cur_idx#0 ] : zp ZP_BYTE:18 , reg byte a , reg byte x , reg byte y , +Potential registers zp ZP_BYTE:19 [ plexSort::s#2 ] : zp ZP_BYTE:19 , reg byte a , reg byte x , reg byte y , + +REGISTER UPLIFT SCOPES +Uplift Scope [plexSort] 367.83: zp ZP_BYTE:9 [ plexSort::s#3 plexSort::s#1 plexSort::s#6 ] 22: zp ZP_BYTE:18 [ plexSort::cur_idx#0 ] 22: zp ZP_BYTE:19 [ plexSort::s#2 ] 20.73: zp ZP_BYTE:8 [ plexSort::m#2 plexSort::m#1 ] 13.67: zp ZP_BYTE:17 [ plexSort::nxt_y#0 ] 3: zp ZP_BYTE:16 [ plexSort::nxt_idx#0 ] +Uplift Scope [] 28.51: zp ZP_WORD:3 [ print_line_cursor#12 print_line_cursor#34 print_line_cursor#1 ] 23.43: zp ZP_WORD:6 [ print_char_cursor#24 print_char_cursor#40 print_char_cursor#44 print_char_cursor#47 print_char_cursor#25 ] +Uplift Scope [plexInit] 38.5: zp ZP_BYTE:12 [ plexInit::i#2 plexInit::i#1 ] +Uplift Scope [print_cls] 33: zp ZP_WORD:10 [ print_cls::sc#2 print_cls::sc#1 ] +Uplift Scope [print_plex] 23.1: zp ZP_BYTE:2 [ print_plex::i#2 print_plex::i#1 ] +Uplift Scope [print_char] 14: zp ZP_BYTE:5 [ print_char::ch#3 print_char::ch#0 print_char::ch#1 ] +Uplift Scope [print_byte] 4: zp ZP_BYTE:14 [ print_byte::$0 ] 4: zp ZP_BYTE:15 [ print_byte::$2 ] 3.75: zp ZP_BYTE:13 [ print_byte::b#0 ] +Uplift Scope [print_ln] +Uplift Scope [main] + +Uplifting [plexSort] best 6894 combination reg byte x [ plexSort::s#3 plexSort::s#1 plexSort::s#6 ] reg byte y [ plexSort::cur_idx#0 ] reg byte x [ plexSort::s#2 ] zp ZP_BYTE:8 [ plexSort::m#2 plexSort::m#1 ] zp ZP_BYTE:17 [ plexSort::nxt_y#0 ] zp ZP_BYTE:16 [ plexSort::nxt_idx#0 ] +Limited combination testing to 100 combinations of 1296 possible. +Uplifting [] best 6894 combination zp ZP_WORD:3 [ print_line_cursor#12 print_line_cursor#34 print_line_cursor#1 ] zp ZP_WORD:6 [ print_char_cursor#24 print_char_cursor#40 print_char_cursor#44 print_char_cursor#47 print_char_cursor#25 ] +Uplifting [plexInit] best 6774 combination reg byte x [ plexInit::i#2 plexInit::i#1 ] +Uplifting [print_cls] best 6774 combination zp ZP_WORD:10 [ print_cls::sc#2 print_cls::sc#1 ] +Uplifting [print_plex] best 6654 combination reg byte x [ print_plex::i#2 print_plex::i#1 ] +Uplifting [print_char] best 6642 combination reg byte a [ print_char::ch#3 print_char::ch#0 print_char::ch#1 ] +Uplifting [print_byte] best 6634 combination reg byte a [ print_byte::$0 ] reg byte a [ print_byte::$2 ] zp ZP_BYTE:13 [ print_byte::b#0 ] +Uplifting [print_ln] best 6634 combination +Uplifting [main] best 6634 combination +Attempting to uplift remaining variables inzp ZP_BYTE:8 [ plexSort::m#2 plexSort::m#1 ] +Uplifting [plexSort] best 6634 combination zp ZP_BYTE:8 [ plexSort::m#2 plexSort::m#1 ] +Attempting to uplift remaining variables inzp ZP_BYTE:17 [ plexSort::nxt_y#0 ] +Uplifting [plexSort] best 6634 combination zp ZP_BYTE:17 [ plexSort::nxt_y#0 ] +Attempting to uplift remaining variables inzp ZP_BYTE:13 [ print_byte::b#0 ] +Uplifting [print_byte] best 6634 combination zp ZP_BYTE:13 [ print_byte::b#0 ] +Attempting to uplift remaining variables inzp ZP_BYTE:16 [ plexSort::nxt_idx#0 ] +Uplifting [plexSort] best 6634 combination zp ZP_BYTE:16 [ plexSort::nxt_idx#0 ] +Coalescing zero page register [ zp ZP_WORD:3 [ print_line_cursor#12 print_line_cursor#34 print_line_cursor#1 ] ] with [ zp ZP_WORD:10 [ print_cls::sc#2 print_cls::sc#1 ] ] +Coalescing zero page register [ zp ZP_BYTE:8 [ plexSort::m#2 plexSort::m#1 ] ] with [ zp ZP_BYTE:13 [ print_byte::b#0 ] ] +Allocated (was zp ZP_WORD:3) zp ZP_WORD:2 [ print_line_cursor#12 print_line_cursor#34 print_line_cursor#1 print_cls::sc#2 print_cls::sc#1 ] +Allocated (was zp ZP_WORD:6) zp ZP_WORD:4 [ print_char_cursor#24 print_char_cursor#40 print_char_cursor#44 print_char_cursor#47 print_char_cursor#25 ] +Allocated (was zp ZP_BYTE:8) zp ZP_BYTE:6 [ plexSort::m#2 plexSort::m#1 print_byte::b#0 ] +Allocated (was zp ZP_BYTE:16) zp ZP_BYTE:7 [ plexSort::nxt_idx#0 ] +Allocated (was zp ZP_BYTE:17) zp ZP_BYTE:8 [ plexSort::nxt_y#0 ] + +ASSEMBLER BEFORE OPTIMIZATION +//SEG0 Basic Upstart +.pc = $801 "Basic" +:BasicUpstart(main) +.pc = $80d "Program" +//SEG1 Global Constants & labels + .const PLEX_COUNT = $a + .label print_line_cursor = 2 + .label print_char_cursor = 4 +//SEG2 @begin +bbegin: +//SEG3 [1] phi from @begin to @19 [phi:@begin->@19] +b19_from_bbegin: + jmp b19 +//SEG4 @19 +b19: +//SEG5 [2] call main [ ] ( ) +//SEG6 [4] phi from @19 to main [phi:@19->main] +main_from_b19: + jsr main +//SEG7 [3] phi from @19 to @end [phi:@19->@end] +bend_from_b19: + jmp bend +//SEG8 @end +bend: +//SEG9 main +main: { + //SEG10 [5] call plexInit [ ] ( main:2 [ ] ) + //SEG11 [65] phi from main to plexInit [phi:main->plexInit] + plexInit_from_main: + jsr plexInit + //SEG12 [6] phi from main to main::@1 [phi:main->main::@1] + b1_from_main: + jmp b1 + //SEG13 main::@1 + b1: + //SEG14 [7] call print_cls [ ] ( main:2 [ ] ) + //SEG15 [59] phi from main::@1 to print_cls [phi:main::@1->print_cls] + print_cls_from_b1: + jsr print_cls + //SEG16 [8] phi from main::@1 to main::@2 [phi:main::@1->main::@2] + b2_from_b1: + jmp b2 + //SEG17 main::@2 + b2: + //SEG18 [9] call print_plex [ print_line_cursor#1 ] ( main:2 [ print_line_cursor#1 ] ) + //SEG19 [15] phi from main::@2 to print_plex [phi:main::@2->print_plex] + print_plex_from_b2: + //SEG20 [15] phi (byte*) print_line_cursor#34 = ((byte*))(word/signed word/dword/signed dword) 1024 [phi:main::@2->print_plex#0] -- pbuz1=pbuc1 + lda #<$400 + sta print_line_cursor + lda #>$400 + sta print_line_cursor+1 + //SEG21 [15] phi (byte*) print_char_cursor#44 = ((byte*))(word/signed word/dword/signed dword) 1024 [phi:main::@2->print_plex#1] -- pbuz1=pbuc1 + lda #<$400 + sta print_char_cursor + lda #>$400 + sta print_char_cursor+1 + jsr print_plex + //SEG22 [10] phi from main::@2 to main::@3 [phi:main::@2->main::@3] + b3_from_b2: + jmp b3 + //SEG23 main::@3 + b3: + //SEG24 [11] call plexSort [ print_line_cursor#1 ] ( main:2 [ print_line_cursor#1 ] ) + //SEG25 [42] phi from main::@3 to plexSort [phi:main::@3->plexSort] + plexSort_from_b3: + jsr plexSort + jmp b4 + //SEG26 main::@4 + b4: + //SEG27 [12] (byte*~) print_char_cursor#47 ← (byte*) print_line_cursor#1 [ print_char_cursor#47 print_line_cursor#1 ] ( main:2 [ print_char_cursor#47 print_line_cursor#1 ] ) -- pbuz1=pbuz2 + lda print_line_cursor + sta print_char_cursor + lda print_line_cursor+1 + sta print_char_cursor+1 + //SEG28 [13] call print_plex [ ] ( main:2 [ ] ) + //SEG29 [15] phi from main::@4 to print_plex [phi:main::@4->print_plex] + print_plex_from_b4: + //SEG30 [15] phi (byte*) print_line_cursor#34 = (byte*) print_line_cursor#1 [phi:main::@4->print_plex#0] -- register_copy + //SEG31 [15] phi (byte*) print_char_cursor#44 = (byte*~) print_char_cursor#47 [phi:main::@4->print_plex#1] -- register_copy + jsr print_plex + jmp breturn + //SEG32 main::@return + breturn: + //SEG33 [14] return [ ] ( main:2 [ ] ) + rts +} +//SEG34 print_plex +print_plex: { + //SEG35 [16] phi from print_plex to print_plex::@1 [phi:print_plex->print_plex::@1] + b1_from_print_plex: + //SEG36 [16] phi (byte*) print_char_cursor#40 = (byte*) print_char_cursor#44 [phi:print_plex->print_plex::@1#0] -- register_copy + //SEG37 [16] phi (byte) print_plex::i#2 = (byte/signed byte/word/signed word/dword/signed dword) 0 [phi:print_plex->print_plex::@1#1] -- vbuxx=vbuc1 + ldx #0 + jmp b1 + //SEG38 [16] phi from print_plex::@4 to print_plex::@1 [phi:print_plex::@4->print_plex::@1] + b1_from_b4: + //SEG39 [16] phi (byte*) print_char_cursor#40 = (byte*) print_char_cursor#25 [phi:print_plex::@4->print_plex::@1#0] -- register_copy + //SEG40 [16] phi (byte) print_plex::i#2 = (byte) print_plex::i#1 [phi:print_plex::@4->print_plex::@1#1] -- register_copy + jmp b1 + //SEG41 print_plex::@1 + b1: + //SEG42 [17] (byte) print_byte::b#0 ← *((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) print_plex::i#2)) [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 ] ) -- vbuz1=pbuc1_derefidx_pbuc2_derefidx_vbuxx + lda PLEX_SORTED_IDX,x + tay + lda PLEX_YPOS,y + sta print_byte.b + //SEG43 [18] call print_byte [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + jsr print_byte + //SEG44 [19] phi from print_plex::@1 to print_plex::@3 [phi:print_plex::@1->print_plex::@3] + b3_from_b1: + jmp b3 + //SEG45 print_plex::@3 + b3: + //SEG46 [20] call print_char [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + //SEG47 [31] phi from print_plex::@3 to print_char [phi:print_plex::@3->print_char] + print_char_from_b3: + //SEG48 [31] phi (byte*) print_char_cursor#24 = (byte*) print_char_cursor#25 [phi:print_plex::@3->print_char#0] -- register_copy + //SEG49 [31] phi (byte) print_char::ch#3 = (byte) ' ' [phi:print_plex::@3->print_char#1] -- vbuaa=vbuc1 + lda #' ' + jsr print_char + jmp b4 + //SEG50 print_plex::@4 + b4: + //SEG51 [21] (byte) print_plex::i#1 ← ++ (byte) print_plex::i#2 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] ) -- vbuxx=_inc_vbuxx + inx + //SEG52 [22] if((byte) print_plex::i#1!=(const byte) PLEX_COUNT#0-(byte/signed byte/word/signed word/dword/signed dword) 1+(byte/signed byte/word/signed word/dword/signed dword) 1) goto print_plex::@1 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] ) -- vbuxx_neq_vbuc1_then_la1 + cpx #PLEX_COUNT-1+1 + bne b1_from_b4 + //SEG53 [23] phi from print_plex::@4 to print_plex::@2 [phi:print_plex::@4->print_plex::@2] + b2_from_b4: + jmp b2 + //SEG54 print_plex::@2 + b2: + //SEG55 [24] call print_ln [ print_line_cursor#1 ] ( main:2::print_plex:9 [ print_line_cursor#1 ] main:2::print_plex:13 [ print_line_cursor#1 ] ) + //SEG56 [26] phi from print_plex::@2 to print_ln [phi:print_plex::@2->print_ln] + print_ln_from_b2: + jsr print_ln + jmp breturn + //SEG57 print_plex::@return + breturn: + //SEG58 [25] return [ print_line_cursor#1 ] ( main:2::print_plex:9 [ print_line_cursor#1 ] main:2::print_plex:13 [ print_line_cursor#1 ] ) + rts +} +//SEG59 print_ln +print_ln: { + //SEG60 [27] phi from print_ln print_ln::@1 to print_ln::@1 [phi:print_ln/print_ln::@1->print_ln::@1] + b1_from_print_ln: + b1_from_b1: + //SEG61 [27] phi (byte*) print_line_cursor#12 = (byte*) print_line_cursor#34 [phi:print_ln/print_ln::@1->print_ln::@1#0] -- register_copy + jmp b1 + //SEG62 print_ln::@1 + b1: + //SEG63 [28] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#12 + (byte/signed byte/word/signed word/dword/signed dword) 40 [ print_line_cursor#1 print_char_cursor#25 ] ( main:2::print_plex:9::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] main:2::print_plex:13::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] ) -- pbuz1=pbuz1_plus_vbuc1 + lda print_line_cursor + clc + adc #$28 + sta print_line_cursor + bcc !+ + inc print_line_cursor+1 + !: + //SEG64 [29] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#25) goto print_ln::@1 [ print_line_cursor#1 print_char_cursor#25 ] ( main:2::print_plex:9::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] main:2::print_plex:13::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] ) -- pbuz1_lt_pbuz2_then_la1 + lda print_line_cursor+1 + cmp print_char_cursor+1 + bcc b1_from_b1 + bne !+ + lda print_line_cursor + cmp print_char_cursor + bcc b1_from_b1 + !: + jmp breturn + //SEG65 print_ln::@return + breturn: + //SEG66 [30] return [ print_line_cursor#1 ] ( main:2::print_plex:9::print_ln:24 [ print_line_cursor#1 ] main:2::print_plex:13::print_ln:24 [ print_line_cursor#1 ] ) + rts +} +//SEG67 print_char +print_char: { + //SEG68 [32] *((byte*) print_char_cursor#24) ← (byte) print_char::ch#3 [ print_char_cursor#24 ] ( main:2::print_plex:9::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] main:2::print_plex:13::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] ) -- _deref_pbuz1=vbuaa + ldy #0 + sta (print_char_cursor),y + //SEG69 [33] (byte*) print_char_cursor#25 ← ++ (byte*) print_char_cursor#24 [ print_char_cursor#25 ] ( main:2::print_plex:9::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:9::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#25 ] main:2::print_plex:9::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) -- pbuz1=_inc_pbuz1 + inc print_char_cursor + bne !+ + inc print_char_cursor+1 + !: + jmp breturn + //SEG70 print_char::@return + breturn: + //SEG71 [34] return [ print_char_cursor#25 ] ( main:2::print_plex:9::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:9::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#25 ] main:2::print_plex:9::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + rts +} +//SEG72 print_byte +print_byte: { + .label b = 6 + //SEG73 [35] (byte~) print_byte::$0 ← (byte) print_byte::b#0 >> (byte/signed byte/word/signed word/dword/signed dword) 4 [ print_char_cursor#40 print_byte::b#0 print_byte::$0 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_byte::$0 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_byte::$0 ] ) -- vbuaa=vbuz1_ror_4 + lda b + lsr + lsr + lsr + lsr + //SEG74 [36] (byte) print_char::ch#0 ← *((const byte[]) print_hextab#0 + (byte~) print_byte::$0) [ print_char_cursor#40 print_byte::b#0 print_char::ch#0 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_char::ch#0 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_char::ch#0 ] ) -- vbuaa=pbuc1_derefidx_vbuaa + tay + lda print_hextab,y + //SEG75 [37] call print_char [ print_char_cursor#25 print_byte::b#0 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::b#0 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::b#0 ] ) + //SEG76 [31] phi from print_byte to print_char [phi:print_byte->print_char] + print_char_from_print_byte: + //SEG77 [31] phi (byte*) print_char_cursor#24 = (byte*) print_char_cursor#40 [phi:print_byte->print_char#0] -- register_copy + //SEG78 [31] phi (byte) print_char::ch#3 = (byte) print_char::ch#0 [phi:print_byte->print_char#1] -- register_copy + jsr print_char + jmp b1 + //SEG79 print_byte::@1 + b1: + //SEG80 [38] (byte~) print_byte::$2 ← (byte) print_byte::b#0 & (byte/signed byte/word/signed word/dword/signed dword) 15 [ print_char_cursor#25 print_byte::$2 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::$2 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::$2 ] ) -- vbuaa=vbuz1_band_vbuc1 + lda #$f + and b + //SEG81 [39] (byte) print_char::ch#1 ← *((const byte[]) print_hextab#0 + (byte~) print_byte::$2) [ print_char_cursor#25 print_char::ch#1 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_char::ch#1 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_char::ch#1 ] ) -- vbuaa=pbuc1_derefidx_vbuaa + tay + lda print_hextab,y + //SEG82 [40] call print_char [ print_char_cursor#25 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + //SEG83 [31] phi from print_byte::@1 to print_char [phi:print_byte::@1->print_char] + print_char_from_b1: + //SEG84 [31] phi (byte*) print_char_cursor#24 = (byte*) print_char_cursor#25 [phi:print_byte::@1->print_char#0] -- register_copy + //SEG85 [31] phi (byte) print_char::ch#3 = (byte) print_char::ch#1 [phi:print_byte::@1->print_char#1] -- register_copy + jsr print_char + jmp breturn + //SEG86 print_byte::@return + breturn: + //SEG87 [41] return [ print_char_cursor#25 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + rts +} +//SEG88 plexSort +plexSort: { + .label nxt_idx = 7 + .label nxt_y = 8 + .label m = 6 + //SEG89 [43] phi from plexSort to plexSort::@1 [phi:plexSort->plexSort::@1] + b1_from_plexSort: + //SEG90 [43] phi (byte) plexSort::m#2 = (byte/signed byte/word/signed word/dword/signed dword) 0 [phi:plexSort->plexSort::@1#0] -- vbuz1=vbuc1 + lda #0 + sta m + jmp b1 + //SEG91 [43] phi from plexSort::@2 to plexSort::@1 [phi:plexSort::@2->plexSort::@1] + b1_from_b2: + //SEG92 [43] phi (byte) plexSort::m#2 = (byte) plexSort::m#1 [phi:plexSort::@2->plexSort::@1#0] -- register_copy + jmp b1 + //SEG93 plexSort::@1 + b1: + //SEG94 [44] (byte) plexSort::nxt_idx#0 ← *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0+(byte/signed byte/word/signed word/dword/signed dword) 1 + (byte) plexSort::m#2) [ plexSort::m#2 plexSort::nxt_idx#0 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 ] ) -- vbuz1=pbuc1_derefidx_vbuz2 + ldy m + lda PLEX_SORTED_IDX+1,y + sta nxt_idx + //SEG95 [45] (byte) plexSort::nxt_y#0 ← *((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + (byte) plexSort::nxt_idx#0) [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ) -- vbuz1=pbuc1_derefidx_vbuz2 + ldy nxt_idx + lda PLEX_YPOS,y + sta nxt_y + //SEG96 [46] (byte) plexSort::cur_idx#0 ← *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::m#2) [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::cur_idx#0 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::cur_idx#0 ] ) -- vbuyy=pbuc1_derefidx_vbuz1 + ldx m + ldy PLEX_SORTED_IDX,x + //SEG97 [47] if((byte) plexSort::nxt_y#0>=*((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + (byte) plexSort::cur_idx#0)) goto plexSort::@2 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ) -- vbuz1_ge_pbuc1_derefidx_vbuyy_then_la1 + lda nxt_y + cmp PLEX_YPOS,y + bcs b2 + jmp b10 + //SEG98 plexSort::@10 + b10: + //SEG99 [48] (byte~) plexSort::s#6 ← (byte) plexSort::m#2 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#6 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#6 ] ) -- vbuxx=vbuz1 + ldx m + //SEG100 [49] phi from plexSort::@10 plexSort::@7 to plexSort::@3 [phi:plexSort::@10/plexSort::@7->plexSort::@3] + b3_from_b10: + b3_from_b7: + //SEG101 [49] phi (byte) plexSort::s#3 = (byte~) plexSort::s#6 [phi:plexSort::@10/plexSort::@7->plexSort::@3#0] -- register_copy + jmp b3 + //SEG102 plexSort::@3 + b3: + //SEG103 [50] *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0+(byte/signed byte/word/signed word/dword/signed dword) 1 + (byte) plexSort::s#3) ← *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#3) [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#3 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#3 ] ) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx + lda PLEX_SORTED_IDX,x + sta PLEX_SORTED_IDX+1,x + //SEG104 [51] (byte) plexSort::s#1 ← -- (byte) plexSort::s#3 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ) -- vbuxx=_dec_vbuxx + dex + //SEG105 [52] if((byte) plexSort::s#1!=(byte/word/signed word/dword/signed dword) 255) goto plexSort::@7 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ) -- vbuxx_neq_vbuc1_then_la1 + cpx #$ff + bne b7 + jmp b5 + //SEG106 plexSort::@5 + b5: + //SEG107 [53] (byte) plexSort::s#2 ← ++ (byte) plexSort::s#1 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::s#2 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::s#2 ] ) -- vbuxx=_inc_vbuxx + inx + //SEG108 [54] *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#2) ← (byte) plexSort::nxt_idx#0 [ plexSort::m#2 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 ] ) -- pbuc1_derefidx_vbuxx=vbuz1 + lda nxt_idx + sta PLEX_SORTED_IDX,x + jmp b2 + //SEG109 plexSort::@2 + b2: + //SEG110 [55] (byte) plexSort::m#1 ← ++ (byte) plexSort::m#2 [ plexSort::m#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#1 ] ) -- vbuz1=_inc_vbuz1 + inc m + //SEG111 [56] if((byte) plexSort::m#1!=(const byte) PLEX_COUNT#0-(byte/signed byte/word/signed word/dword/signed dword) 2+(byte/signed byte/word/signed word/dword/signed dword) 1) goto plexSort::@1 [ plexSort::m#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#1 ] ) -- vbuz1_neq_vbuc1_then_la1 + lda m + cmp #PLEX_COUNT-2+1 + bne b1_from_b2 + jmp breturn + //SEG112 plexSort::@return + breturn: + //SEG113 [57] return [ ] ( main:2::plexSort:11 [ print_line_cursor#1 ] ) + rts + //SEG114 plexSort::@7 + b7: + //SEG115 [58] if((byte) plexSort::nxt_y#0<*((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#1))) goto plexSort::@3 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ) -- vbuz1_lt_pbuc1_derefidx_pbuc2_derefidx_vbuxx_then_la1 + lda nxt_y + ldy PLEX_SORTED_IDX,x + cmp PLEX_YPOS,y + bcc b3_from_b7 + jmp b5 +} +//SEG116 print_cls +print_cls: { + .label sc = 2 + //SEG117 [60] phi from print_cls to print_cls::@1 [phi:print_cls->print_cls::@1] + b1_from_print_cls: + //SEG118 [60] phi (byte*) print_cls::sc#2 = ((byte*))(word/signed word/dword/signed dword) 1024 [phi:print_cls->print_cls::@1#0] -- pbuz1=pbuc1 + lda #<$400 + sta sc + lda #>$400 + sta sc+1 + jmp b1 + //SEG119 [60] phi from print_cls::@1 to print_cls::@1 [phi:print_cls::@1->print_cls::@1] + b1_from_b1: + //SEG120 [60] phi (byte*) print_cls::sc#2 = (byte*) print_cls::sc#1 [phi:print_cls::@1->print_cls::@1#0] -- register_copy + jmp b1 + //SEG121 print_cls::@1 + b1: + //SEG122 [61] *((byte*) print_cls::sc#2) ← (byte) ' ' [ print_cls::sc#2 ] ( main:2::print_cls:7 [ print_cls::sc#2 ] ) -- _deref_pbuz1=vbuc1 + lda #' ' + ldy #0 + sta (sc),y + //SEG123 [62] (byte*) print_cls::sc#1 ← ++ (byte*) print_cls::sc#2 [ print_cls::sc#1 ] ( main:2::print_cls:7 [ print_cls::sc#1 ] ) -- pbuz1=_inc_pbuz1 + inc sc + bne !+ + inc sc+1 + !: + //SEG124 [63] if((byte*) print_cls::sc#1!=((byte*))(word/signed word/dword/signed dword) 1024+(word/signed word/dword/signed dword) 1000) goto print_cls::@1 [ print_cls::sc#1 ] ( main:2::print_cls:7 [ print_cls::sc#1 ] ) -- pbuz1_neq_pbuc1_then_la1 + lda sc+1 + cmp #>$400+$3e8 + bne b1_from_b1 + lda sc + cmp #<$400+$3e8 + bne b1_from_b1 + jmp breturn + //SEG125 print_cls::@return + breturn: + //SEG126 [64] return [ ] ( main:2::print_cls:7 [ ] ) + rts +} +//SEG127 plexInit +plexInit: { + //SEG128 [66] phi from plexInit to plexInit::@1 [phi:plexInit->plexInit::@1] + b1_from_plexInit: + //SEG129 [66] phi (byte) plexInit::i#2 = (byte/signed byte/word/signed word/dword/signed dword) 0 [phi:plexInit->plexInit::@1#0] -- vbuxx=vbuc1 + ldx #0 + jmp b1 + //SEG130 [66] phi from plexInit::@1 to plexInit::@1 [phi:plexInit::@1->plexInit::@1] + b1_from_b1: + //SEG131 [66] phi (byte) plexInit::i#2 = (byte) plexInit::i#1 [phi:plexInit::@1->plexInit::@1#0] -- register_copy + jmp b1 + //SEG132 plexInit::@1 + b1: + //SEG133 [67] *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexInit::i#2) ← (byte) plexInit::i#2 [ plexInit::i#2 ] ( main:2::plexInit:5 [ plexInit::i#2 ] ) -- pbuc1_derefidx_vbuxx=vbuxx + txa + sta PLEX_SORTED_IDX,x + //SEG134 [68] (byte) plexInit::i#1 ← ++ (byte) plexInit::i#2 [ plexInit::i#1 ] ( main:2::plexInit:5 [ plexInit::i#1 ] ) -- vbuxx=_inc_vbuxx + inx + //SEG135 [69] if((byte) plexInit::i#1!=(const byte) PLEX_COUNT#0-(byte/signed byte/word/signed word/dword/signed dword) 1+(byte/signed byte/word/signed word/dword/signed dword) 1) goto plexInit::@1 [ plexInit::i#1 ] ( main:2::plexInit:5 [ plexInit::i#1 ] ) -- vbuxx_neq_vbuc1_then_la1 + cpx #PLEX_COUNT-1+1 + bne b1_from_b1 + jmp breturn + //SEG136 plexInit::@return + breturn: + //SEG137 [70] return [ ] ( main:2::plexInit:5 [ ] ) + rts +} + print_hextab: .text "0123456789abcdef" + PLEX_YPOS: .byte $ff, $12, $11, $34, 2, $81, $77, $81, $ef, $11 + PLEX_SORTED_IDX: .fill PLEX_COUNT, 0 + +ASSEMBLER OPTIMIZATIONS +Removing instruction jmp b19 +Removing instruction jmp bend +Removing instruction jmp b1 +Removing instruction jmp b2 +Removing instruction jmp b3 +Removing instruction jmp b4 +Removing instruction jmp breturn +Removing instruction jmp b1 +Removing instruction jmp b3 +Removing instruction jmp b4 +Removing instruction jmp b2 +Removing instruction jmp breturn +Removing instruction jmp b1 +Removing instruction jmp breturn +Removing instruction jmp breturn +Removing instruction jmp b1 +Removing instruction jmp breturn +Removing instruction jmp b1 +Removing instruction jmp b10 +Removing instruction jmp b3 +Removing instruction jmp b5 +Removing instruction jmp b2 +Removing instruction jmp breturn +Removing instruction jmp b1 +Removing instruction jmp breturn +Removing instruction jmp b1 +Removing instruction jmp breturn +Succesful ASM optimization Pass5NextJumpElimination +Replacing instruction ldy nxt_idx with TAY +Removing instruction lda nxt_y +Succesful ASM optimization Pass5UnnecesaryLoadElimination +Replacing label b1_from_b4 with b1 +Replacing label b1_from_b1 with b1 +Replacing label b1_from_b1 with b1 +Replacing label b1_from_b2 with b1 +Replacing label b3_from_b7 with b3 +Replacing label b1_from_b1 with b1 +Replacing label b1_from_b1 with b1 +Replacing label b1_from_b1 with b1 +Removing instruction bbegin: +Removing instruction b19_from_bbegin: +Removing instruction main_from_b19: +Removing instruction bend_from_b19: +Removing instruction b1_from_main: +Removing instruction print_cls_from_b1: +Removing instruction b2_from_b1: +Removing instruction print_plex_from_b2: +Removing instruction b3_from_b2: +Removing instruction plexSort_from_b3: +Removing instruction b1_from_b4: +Removing instruction b3_from_b1: +Removing instruction print_char_from_b3: +Removing instruction b2_from_b4: +Removing instruction print_ln_from_b2: +Removing instruction b1_from_print_ln: +Removing instruction b1_from_b1: +Removing instruction b1_from_b2: +Removing instruction b3_from_b10: +Removing instruction b3_from_b7: +Removing instruction b1_from_b1: +Removing instruction b1_from_b1: +Succesful ASM optimization Pass5RedundantLabelElimination +Removing instruction b19: +Removing instruction bend: +Removing instruction plexInit_from_main: +Removing instruction b1: +Removing instruction b2: +Removing instruction b3: +Removing instruction b4: +Removing instruction print_plex_from_b4: +Removing instruction breturn: +Removing instruction b1_from_print_plex: +Removing instruction b3: +Removing instruction b4: +Removing instruction b2: +Removing instruction breturn: +Removing instruction breturn: +Removing instruction breturn: +Removing instruction print_char_from_print_byte: +Removing instruction b1: +Removing instruction print_char_from_b1: +Removing instruction breturn: +Removing instruction b1_from_plexSort: +Removing instruction b10: +Removing instruction breturn: +Removing instruction b1_from_print_cls: +Removing instruction breturn: +Removing instruction b1_from_plexInit: +Removing instruction breturn: +Succesful ASM optimization Pass5UnusedLabelElimination +Removing instruction jmp b1 +Removing instruction jmp b1 +Removing instruction jmp b1 +Removing instruction jmp b1 +Succesful ASM optimization Pass5NextJumpElimination +Removing instruction ldx m +Succesful ASM optimization Pass5UnnecesaryLoadElimination + +FINAL SYMBOL TABLE +(label) @19 +(label) @begin +(label) @end +(byte) PLEX_COUNT +(const byte) PLEX_COUNT#0 PLEX_COUNT = (byte/signed byte/word/signed word/dword/signed dword) 10 +(byte[PLEX_COUNT#0]) PLEX_SORTED_IDX +(const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 PLEX_SORTED_IDX = { fill( PLEX_COUNT#0, 0) } +(byte[PLEX_COUNT#0]) PLEX_YPOS +(const byte[PLEX_COUNT#0]) PLEX_YPOS#0 PLEX_YPOS = { (byte/word/signed word/dword/signed dword) 255, (byte/signed byte/word/signed word/dword/signed dword) 18, (byte/signed byte/word/signed word/dword/signed dword) 17, (byte/signed byte/word/signed word/dword/signed dword) 52, (byte/signed byte/word/signed word/dword/signed dword) 2, (byte/word/signed word/dword/signed dword) 129, (byte/signed byte/word/signed word/dword/signed dword) 119, (byte/word/signed word/dword/signed dword) 129, (byte/word/signed word/dword/signed dword) 239, (byte/signed byte/word/signed word/dword/signed dword) 17 } +(void()) main() +(label) main::@1 +(label) main::@2 +(label) main::@3 +(label) main::@4 +(label) main::@return +(void()) plexInit() +(label) plexInit::@1 +(label) plexInit::@return +(byte) plexInit::i +(byte) plexInit::i#1 reg byte x 16.5 +(byte) plexInit::i#2 reg byte x 22.0 +(void()) plexSort() +(label) plexSort::@1 +(label) plexSort::@10 +(label) plexSort::@2 +(label) plexSort::@3 +(label) plexSort::@5 +(label) plexSort::@7 +(label) plexSort::@return +(byte) plexSort::cur_idx +(byte) plexSort::cur_idx#0 reg byte y 22.0 +(byte) plexSort::m +(byte) plexSort::m#1 m zp ZP_BYTE:6 16.5 +(byte) plexSort::m#2 m zp ZP_BYTE:6 4.230769230769231 +(byte) plexSort::nxt_idx +(byte) plexSort::nxt_idx#0 nxt_idx zp ZP_BYTE:7 3.0 +(byte) plexSort::nxt_y +(byte) plexSort::nxt_y#0 nxt_y zp ZP_BYTE:8 13.666666666666666 +(byte) plexSort::s +(byte) plexSort::s#1 reg byte x 138.33333333333334 +(byte) plexSort::s#2 reg byte x 22.0 +(byte) plexSort::s#3 reg byte x 207.5 +(byte~) plexSort::s#6 reg byte x 22.0 +(void()) print_byte((byte) print_byte::b) +(byte~) print_byte::$0 reg byte a 4.0 +(byte~) print_byte::$2 reg byte a 4.0 +(label) print_byte::@1 +(label) print_byte::@return +(byte) print_byte::b +(byte) print_byte::b#0 b zp ZP_BYTE:6 3.75 +(void()) print_char((byte) print_char::ch) +(label) print_char::@return +(byte) print_char::ch +(byte) print_char::ch#0 reg byte a 4.0 +(byte) print_char::ch#1 reg byte a 4.0 +(byte) print_char::ch#3 reg byte a 6.0 +(byte*) print_char_cursor +(byte*) print_char_cursor#24 print_char_cursor zp ZP_WORD:4 9.5 +(byte*) print_char_cursor#25 print_char_cursor zp ZP_WORD:4 2.1764705882352944 +(byte*) print_char_cursor#40 print_char_cursor zp ZP_WORD:4 3.75 +(byte*) print_char_cursor#44 print_char_cursor zp ZP_WORD:4 4.0 +(byte*~) print_char_cursor#47 print_char_cursor zp ZP_WORD:4 4.0 +(void()) print_cls() +(label) print_cls::@1 +(label) print_cls::@return +(byte*) print_cls::sc +(byte*) print_cls::sc#1 sc zp ZP_WORD:2 16.5 +(byte*) print_cls::sc#2 sc zp ZP_WORD:2 16.5 +(byte[]) print_hextab +(const byte[]) print_hextab#0 print_hextab = (string) "0123456789abcdef" +(byte*) print_line_cursor +(byte*) print_line_cursor#1 print_line_cursor zp ZP_WORD:2 4.111111111111112 +(byte*) print_line_cursor#12 print_line_cursor zp ZP_WORD:2 24.0 +(byte*) print_line_cursor#34 print_line_cursor zp ZP_WORD:2 0.4 +(void()) print_ln() +(label) print_ln::@1 +(label) print_ln::@return +(void()) print_plex() +(label) print_plex::@1 +(label) print_plex::@2 +(label) print_plex::@3 +(label) print_plex::@4 +(label) print_plex::@return +(byte) print_plex::i +(byte) print_plex::i#1 reg byte x 16.5 +(byte) print_plex::i#2 reg byte x 6.6000000000000005 +(byte*) print_screen + +reg byte x [ print_plex::i#2 print_plex::i#1 ] +zp ZP_WORD:2 [ print_line_cursor#12 print_line_cursor#34 print_line_cursor#1 print_cls::sc#2 print_cls::sc#1 ] +reg byte a [ print_char::ch#3 print_char::ch#0 print_char::ch#1 ] +zp ZP_WORD:4 [ print_char_cursor#24 print_char_cursor#40 print_char_cursor#44 print_char_cursor#47 print_char_cursor#25 ] +zp ZP_BYTE:6 [ plexSort::m#2 plexSort::m#1 print_byte::b#0 ] +reg byte x [ plexSort::s#3 plexSort::s#1 plexSort::s#6 ] +reg byte x [ plexInit::i#2 plexInit::i#1 ] +reg byte a [ print_byte::$0 ] +reg byte a [ print_byte::$2 ] +zp ZP_BYTE:7 [ plexSort::nxt_idx#0 ] +zp ZP_BYTE:8 [ plexSort::nxt_y#0 ] +reg byte y [ plexSort::cur_idx#0 ] +reg byte x [ plexSort::s#2 ] + + +FINAL ASSEMBLER +Score: 5445 + +//SEG0 Basic Upstart +.pc = $801 "Basic" +:BasicUpstart(main) +.pc = $80d "Program" +//SEG1 Global Constants & labels + .const PLEX_COUNT = $a + .label print_line_cursor = 2 + .label print_char_cursor = 4 +//SEG2 @begin +//SEG3 [1] phi from @begin to @19 [phi:@begin->@19] +//SEG4 @19 +//SEG5 [2] call main [ ] ( ) +//SEG6 [4] phi from @19 to main [phi:@19->main] + jsr main +//SEG7 [3] phi from @19 to @end [phi:@19->@end] +//SEG8 @end +//SEG9 main +main: { + //SEG10 [5] call plexInit [ ] ( main:2 [ ] ) + //SEG11 [65] phi from main to plexInit [phi:main->plexInit] + jsr plexInit + //SEG12 [6] phi from main to main::@1 [phi:main->main::@1] + //SEG13 main::@1 + //SEG14 [7] call print_cls [ ] ( main:2 [ ] ) + //SEG15 [59] phi from main::@1 to print_cls [phi:main::@1->print_cls] + jsr print_cls + //SEG16 [8] phi from main::@1 to main::@2 [phi:main::@1->main::@2] + //SEG17 main::@2 + //SEG18 [9] call print_plex [ print_line_cursor#1 ] ( main:2 [ print_line_cursor#1 ] ) + //SEG19 [15] phi from main::@2 to print_plex [phi:main::@2->print_plex] + //SEG20 [15] phi (byte*) print_line_cursor#34 = ((byte*))(word/signed word/dword/signed dword) 1024 [phi:main::@2->print_plex#0] -- pbuz1=pbuc1 + lda #<$400 + sta print_line_cursor + lda #>$400 + sta print_line_cursor+1 + //SEG21 [15] phi (byte*) print_char_cursor#44 = ((byte*))(word/signed word/dword/signed dword) 1024 [phi:main::@2->print_plex#1] -- pbuz1=pbuc1 + lda #<$400 + sta print_char_cursor + lda #>$400 + sta print_char_cursor+1 + jsr print_plex + //SEG22 [10] phi from main::@2 to main::@3 [phi:main::@2->main::@3] + //SEG23 main::@3 + //SEG24 [11] call plexSort [ print_line_cursor#1 ] ( main:2 [ print_line_cursor#1 ] ) + //SEG25 [42] phi from main::@3 to plexSort [phi:main::@3->plexSort] + jsr plexSort + //SEG26 main::@4 + //SEG27 [12] (byte*~) print_char_cursor#47 ← (byte*) print_line_cursor#1 [ print_char_cursor#47 print_line_cursor#1 ] ( main:2 [ print_char_cursor#47 print_line_cursor#1 ] ) -- pbuz1=pbuz2 + lda print_line_cursor + sta print_char_cursor + lda print_line_cursor+1 + sta print_char_cursor+1 + //SEG28 [13] call print_plex [ ] ( main:2 [ ] ) + //SEG29 [15] phi from main::@4 to print_plex [phi:main::@4->print_plex] + //SEG30 [15] phi (byte*) print_line_cursor#34 = (byte*) print_line_cursor#1 [phi:main::@4->print_plex#0] -- register_copy + //SEG31 [15] phi (byte*) print_char_cursor#44 = (byte*~) print_char_cursor#47 [phi:main::@4->print_plex#1] -- register_copy + jsr print_plex + //SEG32 main::@return + //SEG33 [14] return [ ] ( main:2 [ ] ) + rts +} +//SEG34 print_plex +print_plex: { + //SEG35 [16] phi from print_plex to print_plex::@1 [phi:print_plex->print_plex::@1] + //SEG36 [16] phi (byte*) print_char_cursor#40 = (byte*) print_char_cursor#44 [phi:print_plex->print_plex::@1#0] -- register_copy + //SEG37 [16] phi (byte) print_plex::i#2 = (byte/signed byte/word/signed word/dword/signed dword) 0 [phi:print_plex->print_plex::@1#1] -- vbuxx=vbuc1 + ldx #0 + //SEG38 [16] phi from print_plex::@4 to print_plex::@1 [phi:print_plex::@4->print_plex::@1] + //SEG39 [16] phi (byte*) print_char_cursor#40 = (byte*) print_char_cursor#25 [phi:print_plex::@4->print_plex::@1#0] -- register_copy + //SEG40 [16] phi (byte) print_plex::i#2 = (byte) print_plex::i#1 [phi:print_plex::@4->print_plex::@1#1] -- register_copy + //SEG41 print_plex::@1 + b1: + //SEG42 [17] (byte) print_byte::b#0 ← *((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) print_plex::i#2)) [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 ] ) -- vbuz1=pbuc1_derefidx_pbuc2_derefidx_vbuxx + lda PLEX_SORTED_IDX,x + tay + lda PLEX_YPOS,y + sta print_byte.b + //SEG43 [18] call print_byte [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + jsr print_byte + //SEG44 [19] phi from print_plex::@1 to print_plex::@3 [phi:print_plex::@1->print_plex::@3] + //SEG45 print_plex::@3 + //SEG46 [20] call print_char [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + //SEG47 [31] phi from print_plex::@3 to print_char [phi:print_plex::@3->print_char] + //SEG48 [31] phi (byte*) print_char_cursor#24 = (byte*) print_char_cursor#25 [phi:print_plex::@3->print_char#0] -- register_copy + //SEG49 [31] phi (byte) print_char::ch#3 = (byte) ' ' [phi:print_plex::@3->print_char#1] -- vbuaa=vbuc1 + lda #' ' + jsr print_char + //SEG50 print_plex::@4 + //SEG51 [21] (byte) print_plex::i#1 ← ++ (byte) print_plex::i#2 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] ) -- vbuxx=_inc_vbuxx + inx + //SEG52 [22] if((byte) print_plex::i#1!=(const byte) PLEX_COUNT#0-(byte/signed byte/word/signed word/dword/signed dword) 1+(byte/signed byte/word/signed word/dword/signed dword) 1) goto print_plex::@1 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] ( main:2::print_plex:9 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] main:2::print_plex:13 [ print_line_cursor#34 print_plex::i#1 print_char_cursor#25 ] ) -- vbuxx_neq_vbuc1_then_la1 + cpx #PLEX_COUNT-1+1 + bne b1 + //SEG53 [23] phi from print_plex::@4 to print_plex::@2 [phi:print_plex::@4->print_plex::@2] + //SEG54 print_plex::@2 + //SEG55 [24] call print_ln [ print_line_cursor#1 ] ( main:2::print_plex:9 [ print_line_cursor#1 ] main:2::print_plex:13 [ print_line_cursor#1 ] ) + //SEG56 [26] phi from print_plex::@2 to print_ln [phi:print_plex::@2->print_ln] + jsr print_ln + //SEG57 print_plex::@return + //SEG58 [25] return [ print_line_cursor#1 ] ( main:2::print_plex:9 [ print_line_cursor#1 ] main:2::print_plex:13 [ print_line_cursor#1 ] ) + rts +} +//SEG59 print_ln +print_ln: { + //SEG60 [27] phi from print_ln print_ln::@1 to print_ln::@1 [phi:print_ln/print_ln::@1->print_ln::@1] + //SEG61 [27] phi (byte*) print_line_cursor#12 = (byte*) print_line_cursor#34 [phi:print_ln/print_ln::@1->print_ln::@1#0] -- register_copy + //SEG62 print_ln::@1 + b1: + //SEG63 [28] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#12 + (byte/signed byte/word/signed word/dword/signed dword) 40 [ print_line_cursor#1 print_char_cursor#25 ] ( main:2::print_plex:9::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] main:2::print_plex:13::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] ) -- pbuz1=pbuz1_plus_vbuc1 + lda print_line_cursor + clc + adc #$28 + sta print_line_cursor + bcc !+ + inc print_line_cursor+1 + !: + //SEG64 [29] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#25) goto print_ln::@1 [ print_line_cursor#1 print_char_cursor#25 ] ( main:2::print_plex:9::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] main:2::print_plex:13::print_ln:24 [ print_line_cursor#1 print_char_cursor#25 ] ) -- pbuz1_lt_pbuz2_then_la1 + lda print_line_cursor+1 + cmp print_char_cursor+1 + bcc b1 + bne !+ + lda print_line_cursor + cmp print_char_cursor + bcc b1 + !: + //SEG65 print_ln::@return + //SEG66 [30] return [ print_line_cursor#1 ] ( main:2::print_plex:9::print_ln:24 [ print_line_cursor#1 ] main:2::print_plex:13::print_ln:24 [ print_line_cursor#1 ] ) + rts +} +//SEG67 print_char +print_char: { + //SEG68 [32] *((byte*) print_char_cursor#24) ← (byte) print_char::ch#3 [ print_char_cursor#24 ] ( main:2::print_plex:9::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] main:2::print_plex:13::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#24 ] main:2::print_plex:9::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] main:2::print_plex:13::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#24 ] ) -- _deref_pbuz1=vbuaa + ldy #0 + sta (print_char_cursor),y + //SEG69 [33] (byte*) print_char_cursor#25 ← ++ (byte*) print_char_cursor#24 [ print_char_cursor#25 ] ( main:2::print_plex:9::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:9::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#25 ] main:2::print_plex:9::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) -- pbuz1=_inc_pbuz1 + inc print_char_cursor + bne !+ + inc print_char_cursor+1 + !: + //SEG70 print_char::@return + //SEG71 [34] return [ print_char_cursor#25 ] ( main:2::print_plex:9::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_char:20 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:9::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18::print_char:37 [ print_line_cursor#34 print_plex::i#2 print_byte::b#0 print_char_cursor#25 ] main:2::print_plex:9::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18::print_char:40 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + rts +} +//SEG72 print_byte +print_byte: { + .label b = 6 + //SEG73 [35] (byte~) print_byte::$0 ← (byte) print_byte::b#0 >> (byte/signed byte/word/signed word/dword/signed dword) 4 [ print_char_cursor#40 print_byte::b#0 print_byte::$0 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_byte::$0 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_byte::$0 ] ) -- vbuaa=vbuz1_ror_4 + lda b + lsr + lsr + lsr + lsr + //SEG74 [36] (byte) print_char::ch#0 ← *((const byte[]) print_hextab#0 + (byte~) print_byte::$0) [ print_char_cursor#40 print_byte::b#0 print_char::ch#0 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_char::ch#0 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#40 print_byte::b#0 print_char::ch#0 ] ) -- vbuaa=pbuc1_derefidx_vbuaa + tay + lda print_hextab,y + //SEG75 [37] call print_char [ print_char_cursor#25 print_byte::b#0 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::b#0 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::b#0 ] ) + //SEG76 [31] phi from print_byte to print_char [phi:print_byte->print_char] + //SEG77 [31] phi (byte*) print_char_cursor#24 = (byte*) print_char_cursor#40 [phi:print_byte->print_char#0] -- register_copy + //SEG78 [31] phi (byte) print_char::ch#3 = (byte) print_char::ch#0 [phi:print_byte->print_char#1] -- register_copy + jsr print_char + //SEG79 print_byte::@1 + //SEG80 [38] (byte~) print_byte::$2 ← (byte) print_byte::b#0 & (byte/signed byte/word/signed word/dword/signed dword) 15 [ print_char_cursor#25 print_byte::$2 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::$2 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_byte::$2 ] ) -- vbuaa=vbuz1_band_vbuc1 + lda #$f + and b + //SEG81 [39] (byte) print_char::ch#1 ← *((const byte[]) print_hextab#0 + (byte~) print_byte::$2) [ print_char_cursor#25 print_char::ch#1 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_char::ch#1 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 print_char::ch#1 ] ) -- vbuaa=pbuc1_derefidx_vbuaa + tay + lda print_hextab,y + //SEG82 [40] call print_char [ print_char_cursor#25 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + //SEG83 [31] phi from print_byte::@1 to print_char [phi:print_byte::@1->print_char] + //SEG84 [31] phi (byte*) print_char_cursor#24 = (byte*) print_char_cursor#25 [phi:print_byte::@1->print_char#0] -- register_copy + //SEG85 [31] phi (byte) print_char::ch#3 = (byte) print_char::ch#1 [phi:print_byte::@1->print_char#1] -- register_copy + jsr print_char + //SEG86 print_byte::@return + //SEG87 [41] return [ print_char_cursor#25 ] ( main:2::print_plex:9::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] main:2::print_plex:13::print_byte:18 [ print_line_cursor#34 print_plex::i#2 print_char_cursor#25 ] ) + rts +} +//SEG88 plexSort +plexSort: { + .label nxt_idx = 7 + .label nxt_y = 8 + .label m = 6 + //SEG89 [43] phi from plexSort to plexSort::@1 [phi:plexSort->plexSort::@1] + //SEG90 [43] phi (byte) plexSort::m#2 = (byte/signed byte/word/signed word/dword/signed dword) 0 [phi:plexSort->plexSort::@1#0] -- vbuz1=vbuc1 + lda #0 + sta m + //SEG91 [43] phi from plexSort::@2 to plexSort::@1 [phi:plexSort::@2->plexSort::@1] + //SEG92 [43] phi (byte) plexSort::m#2 = (byte) plexSort::m#1 [phi:plexSort::@2->plexSort::@1#0] -- register_copy + //SEG93 plexSort::@1 + b1: + //SEG94 [44] (byte) plexSort::nxt_idx#0 ← *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0+(byte/signed byte/word/signed word/dword/signed dword) 1 + (byte) plexSort::m#2) [ plexSort::m#2 plexSort::nxt_idx#0 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 ] ) -- vbuz1=pbuc1_derefidx_vbuz2 + ldy m + lda PLEX_SORTED_IDX+1,y + sta nxt_idx + //SEG95 [45] (byte) plexSort::nxt_y#0 ← *((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + (byte) plexSort::nxt_idx#0) [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ) -- vbuz1=pbuc1_derefidx_vbuz2 + tay + lda PLEX_YPOS,y + sta nxt_y + //SEG96 [46] (byte) plexSort::cur_idx#0 ← *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::m#2) [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::cur_idx#0 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::cur_idx#0 ] ) -- vbuyy=pbuc1_derefidx_vbuz1 + ldx m + ldy PLEX_SORTED_IDX,x + //SEG97 [47] if((byte) plexSort::nxt_y#0>=*((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + (byte) plexSort::cur_idx#0)) goto plexSort::@2 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 ] ) -- vbuz1_ge_pbuc1_derefidx_vbuyy_then_la1 + cmp PLEX_YPOS,y + bcs b2 + //SEG98 plexSort::@10 + //SEG99 [48] (byte~) plexSort::s#6 ← (byte) plexSort::m#2 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#6 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#6 ] ) -- vbuxx=vbuz1 + //SEG100 [49] phi from plexSort::@10 plexSort::@7 to plexSort::@3 [phi:plexSort::@10/plexSort::@7->plexSort::@3] + //SEG101 [49] phi (byte) plexSort::s#3 = (byte~) plexSort::s#6 [phi:plexSort::@10/plexSort::@7->plexSort::@3#0] -- register_copy + //SEG102 plexSort::@3 + b3: + //SEG103 [50] *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0+(byte/signed byte/word/signed word/dword/signed dword) 1 + (byte) plexSort::s#3) ← *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#3) [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#3 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#3 ] ) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx + lda PLEX_SORTED_IDX,x + sta PLEX_SORTED_IDX+1,x + //SEG104 [51] (byte) plexSort::s#1 ← -- (byte) plexSort::s#3 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ) -- vbuxx=_dec_vbuxx + dex + //SEG105 [52] if((byte) plexSort::s#1!=(byte/word/signed word/dword/signed dword) 255) goto plexSort::@7 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ) -- vbuxx_neq_vbuc1_then_la1 + cpx #$ff + bne b7 + //SEG106 plexSort::@5 + b5: + //SEG107 [53] (byte) plexSort::s#2 ← ++ (byte) plexSort::s#1 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::s#2 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::s#2 ] ) -- vbuxx=_inc_vbuxx + inx + //SEG108 [54] *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#2) ← (byte) plexSort::nxt_idx#0 [ plexSort::m#2 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 ] ) -- pbuc1_derefidx_vbuxx=vbuz1 + lda nxt_idx + sta PLEX_SORTED_IDX,x + //SEG109 plexSort::@2 + b2: + //SEG110 [55] (byte) plexSort::m#1 ← ++ (byte) plexSort::m#2 [ plexSort::m#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#1 ] ) -- vbuz1=_inc_vbuz1 + inc m + //SEG111 [56] if((byte) plexSort::m#1!=(const byte) PLEX_COUNT#0-(byte/signed byte/word/signed word/dword/signed dword) 2+(byte/signed byte/word/signed word/dword/signed dword) 1) goto plexSort::@1 [ plexSort::m#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#1 ] ) -- vbuz1_neq_vbuc1_then_la1 + lda m + cmp #PLEX_COUNT-2+1 + bne b1 + //SEG112 plexSort::@return + //SEG113 [57] return [ ] ( main:2::plexSort:11 [ print_line_cursor#1 ] ) + rts + //SEG114 plexSort::@7 + b7: + //SEG115 [58] if((byte) plexSort::nxt_y#0<*((const byte[PLEX_COUNT#0]) PLEX_YPOS#0 + *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexSort::s#1))) goto plexSort::@3 [ plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ( main:2::plexSort:11 [ print_line_cursor#1 plexSort::m#2 plexSort::nxt_idx#0 plexSort::nxt_y#0 plexSort::s#1 ] ) -- vbuz1_lt_pbuc1_derefidx_pbuc2_derefidx_vbuxx_then_la1 + lda nxt_y + ldy PLEX_SORTED_IDX,x + cmp PLEX_YPOS,y + bcc b3 + jmp b5 +} +//SEG116 print_cls +print_cls: { + .label sc = 2 + //SEG117 [60] phi from print_cls to print_cls::@1 [phi:print_cls->print_cls::@1] + //SEG118 [60] phi (byte*) print_cls::sc#2 = ((byte*))(word/signed word/dword/signed dword) 1024 [phi:print_cls->print_cls::@1#0] -- pbuz1=pbuc1 + lda #<$400 + sta sc + lda #>$400 + sta sc+1 + //SEG119 [60] phi from print_cls::@1 to print_cls::@1 [phi:print_cls::@1->print_cls::@1] + //SEG120 [60] phi (byte*) print_cls::sc#2 = (byte*) print_cls::sc#1 [phi:print_cls::@1->print_cls::@1#0] -- register_copy + //SEG121 print_cls::@1 + b1: + //SEG122 [61] *((byte*) print_cls::sc#2) ← (byte) ' ' [ print_cls::sc#2 ] ( main:2::print_cls:7 [ print_cls::sc#2 ] ) -- _deref_pbuz1=vbuc1 + lda #' ' + ldy #0 + sta (sc),y + //SEG123 [62] (byte*) print_cls::sc#1 ← ++ (byte*) print_cls::sc#2 [ print_cls::sc#1 ] ( main:2::print_cls:7 [ print_cls::sc#1 ] ) -- pbuz1=_inc_pbuz1 + inc sc + bne !+ + inc sc+1 + !: + //SEG124 [63] if((byte*) print_cls::sc#1!=((byte*))(word/signed word/dword/signed dword) 1024+(word/signed word/dword/signed dword) 1000) goto print_cls::@1 [ print_cls::sc#1 ] ( main:2::print_cls:7 [ print_cls::sc#1 ] ) -- pbuz1_neq_pbuc1_then_la1 + lda sc+1 + cmp #>$400+$3e8 + bne b1 + lda sc + cmp #<$400+$3e8 + bne b1 + //SEG125 print_cls::@return + //SEG126 [64] return [ ] ( main:2::print_cls:7 [ ] ) + rts +} +//SEG127 plexInit +plexInit: { + //SEG128 [66] phi from plexInit to plexInit::@1 [phi:plexInit->plexInit::@1] + //SEG129 [66] phi (byte) plexInit::i#2 = (byte/signed byte/word/signed word/dword/signed dword) 0 [phi:plexInit->plexInit::@1#0] -- vbuxx=vbuc1 + ldx #0 + //SEG130 [66] phi from plexInit::@1 to plexInit::@1 [phi:plexInit::@1->plexInit::@1] + //SEG131 [66] phi (byte) plexInit::i#2 = (byte) plexInit::i#1 [phi:plexInit::@1->plexInit::@1#0] -- register_copy + //SEG132 plexInit::@1 + b1: + //SEG133 [67] *((const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 + (byte) plexInit::i#2) ← (byte) plexInit::i#2 [ plexInit::i#2 ] ( main:2::plexInit:5 [ plexInit::i#2 ] ) -- pbuc1_derefidx_vbuxx=vbuxx + txa + sta PLEX_SORTED_IDX,x + //SEG134 [68] (byte) plexInit::i#1 ← ++ (byte) plexInit::i#2 [ plexInit::i#1 ] ( main:2::plexInit:5 [ plexInit::i#1 ] ) -- vbuxx=_inc_vbuxx + inx + //SEG135 [69] if((byte) plexInit::i#1!=(const byte) PLEX_COUNT#0-(byte/signed byte/word/signed word/dword/signed dword) 1+(byte/signed byte/word/signed word/dword/signed dword) 1) goto plexInit::@1 [ plexInit::i#1 ] ( main:2::plexInit:5 [ plexInit::i#1 ] ) -- vbuxx_neq_vbuc1_then_la1 + cpx #PLEX_COUNT-1+1 + bne b1 + //SEG136 plexInit::@return + //SEG137 [70] return [ ] ( main:2::plexInit:5 [ ] ) + rts +} + print_hextab: .text "0123456789abcdef" + PLEX_YPOS: .byte $ff, $12, $11, $34, 2, $81, $77, $81, $ef, $11 + PLEX_SORTED_IDX: .fill PLEX_COUNT, 0 + diff --git a/src/test/java/dk/camelot64/kickc/test/ref/multiplexer.sym b/src/test/java/dk/camelot64/kickc/test/ref/multiplexer.sym new file mode 100644 index 000000000..b8bac7921 --- /dev/null +++ b/src/test/java/dk/camelot64/kickc/test/ref/multiplexer.sym @@ -0,0 +1,101 @@ +(label) @19 +(label) @begin +(label) @end +(byte) PLEX_COUNT +(const byte) PLEX_COUNT#0 PLEX_COUNT = (byte/signed byte/word/signed word/dword/signed dword) 10 +(byte[PLEX_COUNT#0]) PLEX_SORTED_IDX +(const byte[PLEX_COUNT#0]) PLEX_SORTED_IDX#0 PLEX_SORTED_IDX = { fill( PLEX_COUNT#0, 0) } +(byte[PLEX_COUNT#0]) PLEX_YPOS +(const byte[PLEX_COUNT#0]) PLEX_YPOS#0 PLEX_YPOS = { (byte/word/signed word/dword/signed dword) 255, (byte/signed byte/word/signed word/dword/signed dword) 18, (byte/signed byte/word/signed word/dword/signed dword) 17, (byte/signed byte/word/signed word/dword/signed dword) 52, (byte/signed byte/word/signed word/dword/signed dword) 2, (byte/word/signed word/dword/signed dword) 129, (byte/signed byte/word/signed word/dword/signed dword) 119, (byte/word/signed word/dword/signed dword) 129, (byte/word/signed word/dword/signed dword) 239, (byte/signed byte/word/signed word/dword/signed dword) 17 } +(void()) main() +(label) main::@1 +(label) main::@2 +(label) main::@3 +(label) main::@4 +(label) main::@return +(void()) plexInit() +(label) plexInit::@1 +(label) plexInit::@return +(byte) plexInit::i +(byte) plexInit::i#1 reg byte x 16.5 +(byte) plexInit::i#2 reg byte x 22.0 +(void()) plexSort() +(label) plexSort::@1 +(label) plexSort::@10 +(label) plexSort::@2 +(label) plexSort::@3 +(label) plexSort::@5 +(label) plexSort::@7 +(label) plexSort::@return +(byte) plexSort::cur_idx +(byte) plexSort::cur_idx#0 reg byte y 22.0 +(byte) plexSort::m +(byte) plexSort::m#1 m zp ZP_BYTE:6 16.5 +(byte) plexSort::m#2 m zp ZP_BYTE:6 4.230769230769231 +(byte) plexSort::nxt_idx +(byte) plexSort::nxt_idx#0 nxt_idx zp ZP_BYTE:7 3.0 +(byte) plexSort::nxt_y +(byte) plexSort::nxt_y#0 nxt_y zp ZP_BYTE:8 13.666666666666666 +(byte) plexSort::s +(byte) plexSort::s#1 reg byte x 138.33333333333334 +(byte) plexSort::s#2 reg byte x 22.0 +(byte) plexSort::s#3 reg byte x 207.5 +(byte~) plexSort::s#6 reg byte x 22.0 +(void()) print_byte((byte) print_byte::b) +(byte~) print_byte::$0 reg byte a 4.0 +(byte~) print_byte::$2 reg byte a 4.0 +(label) print_byte::@1 +(label) print_byte::@return +(byte) print_byte::b +(byte) print_byte::b#0 b zp ZP_BYTE:6 3.75 +(void()) print_char((byte) print_char::ch) +(label) print_char::@return +(byte) print_char::ch +(byte) print_char::ch#0 reg byte a 4.0 +(byte) print_char::ch#1 reg byte a 4.0 +(byte) print_char::ch#3 reg byte a 6.0 +(byte*) print_char_cursor +(byte*) print_char_cursor#24 print_char_cursor zp ZP_WORD:4 9.5 +(byte*) print_char_cursor#25 print_char_cursor zp ZP_WORD:4 2.1764705882352944 +(byte*) print_char_cursor#40 print_char_cursor zp ZP_WORD:4 3.75 +(byte*) print_char_cursor#44 print_char_cursor zp ZP_WORD:4 4.0 +(byte*~) print_char_cursor#47 print_char_cursor zp ZP_WORD:4 4.0 +(void()) print_cls() +(label) print_cls::@1 +(label) print_cls::@return +(byte*) print_cls::sc +(byte*) print_cls::sc#1 sc zp ZP_WORD:2 16.5 +(byte*) print_cls::sc#2 sc zp ZP_WORD:2 16.5 +(byte[]) print_hextab +(const byte[]) print_hextab#0 print_hextab = (string) "0123456789abcdef" +(byte*) print_line_cursor +(byte*) print_line_cursor#1 print_line_cursor zp ZP_WORD:2 4.111111111111112 +(byte*) print_line_cursor#12 print_line_cursor zp ZP_WORD:2 24.0 +(byte*) print_line_cursor#34 print_line_cursor zp ZP_WORD:2 0.4 +(void()) print_ln() +(label) print_ln::@1 +(label) print_ln::@return +(void()) print_plex() +(label) print_plex::@1 +(label) print_plex::@2 +(label) print_plex::@3 +(label) print_plex::@4 +(label) print_plex::@return +(byte) print_plex::i +(byte) print_plex::i#1 reg byte x 16.5 +(byte) print_plex::i#2 reg byte x 6.6000000000000005 +(byte*) print_screen + +reg byte x [ print_plex::i#2 print_plex::i#1 ] +zp ZP_WORD:2 [ print_line_cursor#12 print_line_cursor#34 print_line_cursor#1 print_cls::sc#2 print_cls::sc#1 ] +reg byte a [ print_char::ch#3 print_char::ch#0 print_char::ch#1 ] +zp ZP_WORD:4 [ print_char_cursor#24 print_char_cursor#40 print_char_cursor#44 print_char_cursor#47 print_char_cursor#25 ] +zp ZP_BYTE:6 [ plexSort::m#2 plexSort::m#1 print_byte::b#0 ] +reg byte x [ plexSort::s#3 plexSort::s#1 plexSort::s#6 ] +reg byte x [ plexInit::i#2 plexInit::i#1 ] +reg byte a [ print_byte::$0 ] +reg byte a [ print_byte::$2 ] +zp ZP_BYTE:7 [ plexSort::nxt_idx#0 ] +zp ZP_BYTE:8 [ plexSort::nxt_y#0 ] +reg byte y [ plexSort::cur_idx#0 ] +reg byte x [ plexSort::s#2 ] diff --git a/src/test/java/dk/camelot64/kickc/test/ref/scrolllogo.log b/src/test/java/dk/camelot64/kickc/test/ref/scrolllogo.log index 9be54223b..327bd11c0 100644 --- a/src/test/java/dk/camelot64/kickc/test/ref/scrolllogo.log +++ b/src/test/java/dk/camelot64/kickc/test/ref/scrolllogo.log @@ -39,8 +39,7 @@ word xsin_idx = 0; void loop() { while(true) { // Wait for the raster to reach the bottom of the screen - while(*RASTER!=$ff) { - } + while(*RASTER!=$ff) {} (*BORDERCOL)++; signed word xpos = *(xsin+xsin_idx); render_logo(xpos); @@ -107,8 +106,6 @@ void render_logo(signed word xpos) { } } - - Importing c64.kc PARSING src/test/java/dk/camelot64/kickc/test/kc/c64.kc // Commodore 64 Registers and Constants