From 198f4ee55f39eb224780f09be60de3484072b367 Mon Sep 17 00:00:00 2001 From: jespergravgaard Date: Sun, 29 Sep 2019 22:42:37 +0200 Subject: [PATCH] Optimized constant handling in pass 1. --- ...ss1GenerateSingleStaticAssignmentForm.java | 23 +-- src/test/ref/dword.cfg | 2 +- src/test/ref/dword.log | 21 +- src/test/ref/dword.sym | 3 +- src/test/ref/hex2dec.cfg | 4 +- src/test/ref/hex2dec.log | 43 ++-- src/test/ref/hex2dec.sym | 3 +- src/test/ref/pointer-cast-2.cfg | 4 +- src/test/ref/pointer-cast-2.log | 46 ++--- src/test/ref/pointer-cast-2.sym | 6 +- src/test/ref/screen-show-spiral-buckets.cfg | 4 +- src/test/ref/screen-show-spiral-buckets.log | 121 ++++++----- src/test/ref/screen-show-spiral-buckets.sym | 5 +- src/test/ref/test-comparisons.cfg | 20 +- src/test/ref/test-comparisons.log | 191 +++++++++--------- src/test/ref/test-comparisons.sym | 3 +- 16 files changed, 234 insertions(+), 265 deletions(-) diff --git a/src/main/java/dk/camelot64/kickc/passes/Pass1GenerateSingleStaticAssignmentForm.java b/src/main/java/dk/camelot64/kickc/passes/Pass1GenerateSingleStaticAssignmentForm.java index 1bd54a5a3..00c3d8e30 100644 --- a/src/main/java/dk/camelot64/kickc/passes/Pass1GenerateSingleStaticAssignmentForm.java +++ b/src/main/java/dk/camelot64/kickc/passes/Pass1GenerateSingleStaticAssignmentForm.java @@ -7,7 +7,10 @@ import dk.camelot64.kickc.model.Program; import dk.camelot64.kickc.model.iterator.ProgramValue; import dk.camelot64.kickc.model.iterator.ProgramValueIterator; import dk.camelot64.kickc.model.statements.*; -import dk.camelot64.kickc.model.symbols.*; +import dk.camelot64.kickc.model.symbols.Procedure; +import dk.camelot64.kickc.model.symbols.Scope; +import dk.camelot64.kickc.model.symbols.Symbol; +import dk.camelot64.kickc.model.symbols.Variable; import dk.camelot64.kickc.model.types.SymbolType; import dk.camelot64.kickc.model.types.SymbolTypeArray; import dk.camelot64.kickc.model.values.*; @@ -70,6 +73,7 @@ public class Pass1GenerateSingleStaticAssignmentForm extends Pass1Base { /** * Version a single unversioned variable being assigned + * * @param lValueRef The variable being assigned * @param programLValue Program Value usable for updating the variable * @param source The statement source - usable for error messages @@ -78,20 +82,9 @@ public class Pass1GenerateSingleStaticAssignmentForm extends Pass1Base { Collection earlyIdentifiedConstants = getProgram().getEarlyIdentifiedConstants(); Variable assignedVar = getScope().getVariable(lValueRef); if(assignedVar.isStoragePhiMaster()) { - // Assignment to a non-versioned non-intermediary variable - Variable assignedSymbol = assignedVar; - Variable version; - if(assignedSymbol.isDeclaredConstant() || earlyIdentifiedConstants.contains(assignedSymbol.getRef())) { - Collection versions = assignedVar.getScope().getVersions(assignedSymbol); - if(versions.size() != 0) { - throw new CompileError("Error! Constants can not be modified", source); - } - throw new InternalError("ERR!"); - //version = assignedSymbol.createVersion(); - //version.setDeclaredConstant(true); - } else { - version = assignedSymbol.createVersion(); - } + if(assignedVar.isDeclaredConstant() || earlyIdentifiedConstants.contains(assignedVar.getRef())) + throw new InternalError("Error! Constants can not be versioned ", source); + Variable version = assignedVar.createVersion(); programLValue.set(version.getRef()); } } diff --git a/src/test/ref/dword.cfg b/src/test/ref/dword.cfg index a439614f5..b1e6e2ab0 100644 --- a/src/test/ref/dword.cfg +++ b/src/test/ref/dword.cfg @@ -16,7 +16,7 @@ main::@1: scope:[main] from main main::@1 [5] (byte) main::i#2 ← phi( main/(byte) 0 main::@1/(byte) main::i#1 ) [6] (dword) main::b#0 ← (const dword) main::a + (byte) main::i#2 [7] (byte) main::c#0 ← (byte)(dword) main::b#0 - [8] *((const byte*) main::SCREEN#0 + (byte) main::i#2) ← (byte) main::c#0 + [8] *((const byte*) main::SCREEN + (byte) main::i#2) ← (byte) main::c#0 [9] (byte) main::i#1 ← ++ (byte) main::i#2 [10] if((byte) main::i#1!=(byte) $65) goto main::@1 to:main::@return diff --git a/src/test/ref/dword.log b/src/test/ref/dword.log index c026bb528..983fd5459 100644 --- a/src/test/ref/dword.log +++ b/src/test/ref/dword.log @@ -16,8 +16,8 @@ main::@1: scope:[main] from main main::@1 (dword) main::b#0 ← (dword~) main::$0 (byte~) main::$1 ← ((byte)) (dword) main::b#0 (byte) main::c#0 ← (byte~) main::$1 - (byte*) main::SCREEN#0 ← ((byte*)) (number) $400 - *((byte*) main::SCREEN#0 + (byte) main::i#2) ← (byte) main::c#0 + (byte*) main::SCREEN ← ((byte*)) (number) $400 + *((byte*) main::SCREEN + (byte) main::i#2) ← (byte) main::c#0 (byte) main::i#1 ← (byte) main::i#2 + rangenext(0,$64) (bool~) main::$2 ← (byte) main::i#1 != rangelast(0,$64) if((bool~) main::$2) goto main::@1 @@ -44,7 +44,6 @@ SYMBOL TABLE SSA (label) main::@1 (label) main::@return (byte*) main::SCREEN -(byte*) main::SCREEN#0 (dword) main::a (dword) main::b (dword) main::b#0 @@ -59,7 +58,7 @@ Adding number conversion cast (unumber) $ee6b2800 in (dword) main::a ← (number Successful SSA optimization PassNAddNumberTypeConversions Inlining cast (dword) main::a ← (unumber)(number) $ee6b2800 Inlining cast (byte~) main::$1 ← (byte)(dword) main::b#0 -Inlining cast (byte*) main::SCREEN#0 ← (byte*)(number) $400 +Inlining cast (byte*) main::SCREEN ← (byte*)(number) $400 Successful SSA optimization Pass2InlineCast Simplifying constant integer cast $ee6b2800 Simplifying constant pointer cast (byte*) 1024 @@ -73,7 +72,7 @@ Simple Condition (bool~) main::$2 [11] if((byte) main::i#1!=rangelast(0,$64)) go Successful SSA optimization Pass2ConditionalJumpSimplification Constant (const dword) main::a = $ee6b2800 Constant (const byte) main::i#0 = 0 -Constant (const byte*) main::SCREEN#0 = (byte*) 1024 +Constant (const byte*) main::SCREEN = (byte*) 1024 Successful SSA optimization Pass2ConstantIdentification Resolved ranged next value [9] main::i#1 ← ++ main::i#2 to ++ Resolved ranged comparison value [11] if(main::i#1!=rangelast(0,$64)) goto main::@1 to (number) $65 @@ -124,7 +123,7 @@ main::@1: scope:[main] from main main::@1 [5] (byte) main::i#2 ← phi( main/(byte) 0 main::@1/(byte) main::i#1 ) [6] (dword) main::b#0 ← (const dword) main::a + (byte) main::i#2 [7] (byte) main::c#0 ← (byte)(dword) main::b#0 - [8] *((const byte*) main::SCREEN#0 + (byte) main::i#2) ← (byte) main::c#0 + [8] *((const byte*) main::SCREEN + (byte) main::i#2) ← (byte) main::c#0 [9] (byte) main::i#1 ← ++ (byte) main::i#2 [10] if((byte) main::i#1!=(byte) $65) goto main::@1 to:main::@return @@ -135,7 +134,6 @@ main::@return: scope:[main] from main::@1 VARIABLE REGISTER WEIGHTS (void()) main() -(byte*) main::SCREEN (dword) main::b (dword) main::b#0 11.0 (byte) main::c @@ -216,7 +214,7 @@ main: { // [7] (byte) main::c#0 ← (byte)(dword) main::b#0 -- vbuz1=_byte_vduz2 lda.z b sta.z c - // [8] *((const byte*) main::SCREEN#0 + (byte) main::i#2) ← (byte) main::c#0 -- pbuc1_derefidx_vbuz1=vbuz2 + // [8] *((const byte*) main::SCREEN + (byte) main::i#2) ← (byte) main::c#0 -- pbuc1_derefidx_vbuz1=vbuz2 lda.z c ldy.z i sta SCREEN,y @@ -307,7 +305,7 @@ main: { sta.z b+3 // [7] (byte) main::c#0 ← (byte)(dword) main::b#0 -- vbuaa=_byte_vduz1 lda.z b - // [8] *((const byte*) main::SCREEN#0 + (byte) main::i#2) ← (byte) main::c#0 -- pbuc1_derefidx_vbuxx=vbuaa + // [8] *((const byte*) main::SCREEN + (byte) main::i#2) ← (byte) main::c#0 -- pbuc1_derefidx_vbuxx=vbuaa sta SCREEN,x // [9] (byte) main::i#1 ← ++ (byte) main::i#2 -- vbuxx=_inc_vbuxx inx @@ -354,8 +352,7 @@ FINAL SYMBOL TABLE (void()) main() (label) main::@1 (label) main::@return -(byte*) main::SCREEN -(const byte*) main::SCREEN#0 SCREEN = (byte*) 1024 +(const byte*) main::SCREEN SCREEN = (byte*) 1024 (const dword) main::a a = (dword) $ee6b2800 (dword) main::b (dword) main::b#0 b zp ZP_DWORD:2 11.0 @@ -417,7 +414,7 @@ main: { // [7] (byte) main::c#0 ← (byte)(dword) main::b#0 -- vbuaa=_byte_vduz1 lda.z b // SCREEN[i] = c - // [8] *((const byte*) main::SCREEN#0 + (byte) main::i#2) ← (byte) main::c#0 -- pbuc1_derefidx_vbuxx=vbuaa + // [8] *((const byte*) main::SCREEN + (byte) main::i#2) ← (byte) main::c#0 -- pbuc1_derefidx_vbuxx=vbuaa sta SCREEN,x // for( byte i: 0..100) // [9] (byte) main::i#1 ← ++ (byte) main::i#2 -- vbuxx=_inc_vbuxx diff --git a/src/test/ref/dword.sym b/src/test/ref/dword.sym index 8bcbe1fe0..78d5fc43d 100644 --- a/src/test/ref/dword.sym +++ b/src/test/ref/dword.sym @@ -4,8 +4,7 @@ (void()) main() (label) main::@1 (label) main::@return -(byte*) main::SCREEN -(const byte*) main::SCREEN#0 SCREEN = (byte*) 1024 +(const byte*) main::SCREEN SCREEN = (byte*) 1024 (const dword) main::a a = (dword) $ee6b2800 (dword) main::b (dword) main::b#0 b zp ZP_DWORD:2 11.0 diff --git a/src/test/ref/hex2dec.cfg b/src/test/ref/hex2dec.cfg index f994951c9..ac6eac2ea 100644 --- a/src/test/ref/hex2dec.cfg +++ b/src/test/ref/hex2dec.cfg @@ -54,10 +54,10 @@ main::@9: scope:[main] from main::@8 to:main::@3 main::@3: scope:[main] from main::@4 main::@9 [31] (byte) main::i#2 ← phi( main::@9/(byte) 0 main::@4/(byte) main::i#1 ) - [32] if(*((const byte[]) main::msg#0 + (byte) main::i#2)!=(byte) 0) goto main::@4 + [32] if(*((const byte[]) main::msg + (byte) main::i#2)!=(byte) 0) goto main::@4 to:main::@1 main::@4: scope:[main] from main::@3 - [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg#0 + (byte) main::i#2) + [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg + (byte) main::i#2) [34] (byte) main::i#1 ← ++ (byte) main::i#2 to:main::@3 diff --git a/src/test/ref/hex2dec.log b/src/test/ref/hex2dec.log index 18f77b049..172bcc991 100644 --- a/src/test/ref/hex2dec.log +++ b/src/test/ref/hex2dec.log @@ -108,13 +108,13 @@ main::@20: scope:[main] from main::@19 to:main::@21 main::@21: scope:[main] from main::@20 (byte*) main::screen#12 ← phi( main::@20/(byte*) main::screen#9 ) - (byte[]) main::msg#0 ← (const string) main::$21 + (byte[]) main::msg ← (const string) main::$21 (byte) main::i#0 ← (number) 0 to:main::@6 main::@6: scope:[main] from main::@21 main::@7 (byte*) main::screen#11 ← phi( main::@21/(byte*) main::screen#12 main::@7/(byte*) main::screen#10 ) (byte) main::i#2 ← phi( main::@21/(byte) main::i#0 main::@7/(byte) main::i#1 ) - (bool~) main::$18 ← *((byte[]) main::msg#0 + (byte) main::i#2) != (number) 0 + (bool~) main::$18 ← *((byte[]) main::msg + (byte) main::i#2) != (number) 0 if((bool~) main::$18) goto main::@7 to:main::@1 main::@7: scope:[main] from main::@6 @@ -122,7 +122,7 @@ main::@7: scope:[main] from main::@6 (byte*) main::screen#10 ← phi( main::@6/(byte*) main::screen#11 ) (byte*~) main::$19 ← (byte*) main::screen#10 + (number) $50 (byte*~) main::$20 ← (byte*~) main::$19 + (number) 3 - *((byte*~) main::$20 + (byte) main::i#3) ← *((byte[]) main::msg#0 + (byte) main::i#3) + *((byte*~) main::$20 + (byte) main::i#3) ← *((byte[]) main::msg + (byte) main::i#3) (byte) main::i#1 ← ++ (byte) main::i#3 to:main::@6 main::@return: scope:[main] from main::@1 @@ -404,7 +404,6 @@ SYMBOL TABLE SSA (byte) main::i#2 (byte) main::i#3 (byte[]) main::msg -(byte[]) main::msg#0 (byte) main::rst (byte) main::rst#0 (byte*) main::screen @@ -622,7 +621,7 @@ Adding number conversion cast (unumber) $e608 in (word) utoa16w::value#4 ← (nu Adding number conversion cast (unumber) 0 in *((byte*) bordercol) ← (number) 0 Adding number conversion cast (unumber) $50 in (byte*~) main::$16 ← (byte*) main::screen#9 + (number) $50 Adding number conversion cast (unumber) 0 in (byte) main::i#0 ← (number) 0 -Adding number conversion cast (unumber) 0 in (bool~) main::$18 ← *((byte[]) main::msg#0 + (byte) main::i#2) != (number) 0 +Adding number conversion cast (unumber) 0 in (bool~) main::$18 ← *((byte[]) main::msg + (byte) main::i#2) != (number) 0 Adding number conversion cast (unumber) $50 in (byte*~) main::$19 ← (byte*) main::screen#10 + (number) $50 Adding number conversion cast (unumber) 3 in (byte*~) main::$20 ← (byte*~) main::$19 + (number) 3 Adding number conversion cast (unumber) $3e7 in (byte*~) cls::$0 ← (byte*) cls::screen + (number) $3e7 @@ -844,7 +843,7 @@ Identical Phi Values (word) utoa10w::value#5 (word) utoa10w::value#0 Identical Phi Values (byte*) utoa10w::dst#10 (byte*) utoa10w::dst#0 Successful SSA optimization Pass2IdenticalPhiElimination Simple Condition (bool~) main::$4 [11] if((byte) main::rst#0!=(byte) $30) goto main::@4 -Simple Condition (bool~) main::$18 [57] if(*((byte[]) main::msg#0 + (byte) main::i#2)!=(byte) 0) goto main::@7 +Simple Condition (bool~) main::$18 [57] if(*((byte[]) main::msg + (byte) main::i#2)!=(byte) 0) goto main::@7 Simple Condition (bool~) cls::$1 [71] if((byte*) cls::sc#1!=rangelast(cls::screen,cls::$0)) goto cls::@1 Simple Condition (bool~) utoa10w::$1 [83] if((word) utoa10w::value#10>=*((word[]) UTOA10_SUB + (byte~) utoa10w::$8)) goto utoa10w::@3 Simple Condition (bool~) utoa10w::$4 [93] if((byte~) utoa10w::$2==(byte) 0) goto utoa10w::@10 @@ -870,7 +869,7 @@ Constant (const word) utoa16w::value#1 = $4d2 Constant (const word) utoa16w::value#2 = $162e Constant (const word) utoa16w::value#3 = $270f Constant (const word) utoa16w::value#4 = $e608 -Constant (const byte[]) main::msg#0 = main::$21 +Constant (const byte[]) main::msg = main::$21 Constant (const byte) main::i#0 = 0 Constant (const byte*) cls::screen = (byte*) 1024 Constant (const byte[]) DIGITS = $0 @@ -994,7 +993,7 @@ Constant inlined utoa16n::dst#3 = &(byte*) utoa16w::dst#5 Constant inlined utoa16n::started#4 = (byte) 1 Constant inlined utoa16n::dst#2 = &(byte*) utoa16w::dst#5 Constant inlined main::$20 = (byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 -Constant inlined main::$21 = (const byte[]) main::msg#0 +Constant inlined main::$21 = (const byte[]) main::msg Constant inlined utoa16w::started#0 = (byte) 0 Constant inlined cls::$0 = (const byte*) cls::screen+(word) $3e7 Constant inlined utoa10w::i#0 = (byte) 0 @@ -1155,10 +1154,10 @@ main::@9: scope:[main] from main::@8 to:main::@3 main::@3: scope:[main] from main::@4 main::@9 [31] (byte) main::i#2 ← phi( main::@9/(byte) 0 main::@4/(byte) main::i#1 ) - [32] if(*((const byte[]) main::msg#0 + (byte) main::i#2)!=(byte) 0) goto main::@4 + [32] if(*((const byte[]) main::msg + (byte) main::i#2)!=(byte) 0) goto main::@4 to:main::@1 main::@4: scope:[main] from main::@3 - [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg#0 + (byte) main::i#2) + [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg + (byte) main::i#2) [34] (byte) main::i#1 ← ++ (byte) main::i#2 to:main::@3 @@ -1293,7 +1292,6 @@ VARIABLE REGISTER WEIGHTS (byte) main::i (byte) main::i#1 202.0 (byte) main::i#2 168.33333333333331 -(byte[]) main::msg (byte) main::rst (byte) main::rst#0 202.0 (byte*) main::screen @@ -1649,7 +1647,7 @@ main: { jmp b3 // main::@3 b3: - // [32] if(*((const byte[]) main::msg#0 + (byte) main::i#2)!=(byte) 0) goto main::@4 -- pbuc1_derefidx_vbuz1_neq_0_then_la1 + // [32] if(*((const byte[]) main::msg + (byte) main::i#2)!=(byte) 0) goto main::@4 -- pbuc1_derefidx_vbuz1_neq_0_then_la1 ldy.z i lda msg,y cmp #0 @@ -1657,7 +1655,7 @@ main: { jmp b1 // main::@4 b4: - // [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg#0 + (byte) main::i#2) -- pbuc1_derefidx_vbuz1=pbuc2_derefidx_vbuz1 + // [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg + (byte) main::i#2) -- pbuc1_derefidx_vbuz1=pbuc2_derefidx_vbuz1 ldy.z i lda msg,y sta $400+$28+$28+$28+$28+$50+3,y @@ -2079,9 +2077,9 @@ Statement [27] *((const byte*) bordercol) ← (byte) 0 [ main::time_start#0 main Removing always clobbered register reg byte a as potential for zp ZP_BYTE:22 [ main::time_end#0 ] Statement [28] (byte) main::time#0 ← (byte) main::time_end#0 - (byte) main::time_start#0 [ main::time#0 ] ( main:2 [ main::time#0 ] ) always clobbers reg byte a Statement [29] (word) utoa10w::value#0 ← (word)(byte) main::time#0 [ utoa10w::value#0 ] ( main:2 [ utoa10w::value#0 ] ) always clobbers reg byte a -Statement [32] if(*((const byte[]) main::msg#0 + (byte) main::i#2)!=(byte) 0) goto main::@4 [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a +Statement [32] if(*((const byte[]) main::msg + (byte) main::i#2)!=(byte) 0) goto main::@4 [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp ZP_BYTE:2 [ main::i#2 main::i#1 ] -Statement [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg#0 + (byte) main::i#2) [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a +Statement [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg + (byte) main::i#2) [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a Statement [37] (byte~) utoa10w::$8 ← (byte) utoa10w::i#2 << (byte) 1 [ utoa10w::i#2 utoa10w::value#10 utoa10w::digit#3 utoa10w::bStarted#2 utoa10w::dst#11 utoa10w::$8 ] ( main:2::utoa10w:30 [ utoa10w::i#2 utoa10w::value#10 utoa10w::digit#3 utoa10w::bStarted#2 utoa10w::dst#11 utoa10w::$8 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp ZP_BYTE:3 [ utoa10w::i#2 utoa10w::i#1 ] Removing always clobbered register reg byte a as potential for zp ZP_BYTE:6 [ utoa10w::digit#3 utoa10w::digit#7 utoa10w::digit#1 ] @@ -2124,8 +2122,8 @@ Statement [24] (byte*) utoa16w::dst#4 ← (byte*) 1024+(byte) $28+(byte) $28+(by Statement [27] *((const byte*) bordercol) ← (byte) 0 [ main::time_start#0 main::time_end#0 ] ( main:2 [ main::time_start#0 main::time_end#0 ] ) always clobbers reg byte a Statement [28] (byte) main::time#0 ← (byte) main::time_end#0 - (byte) main::time_start#0 [ main::time#0 ] ( main:2 [ main::time#0 ] ) always clobbers reg byte a Statement [29] (word) utoa10w::value#0 ← (word)(byte) main::time#0 [ utoa10w::value#0 ] ( main:2 [ utoa10w::value#0 ] ) always clobbers reg byte a -Statement [32] if(*((const byte[]) main::msg#0 + (byte) main::i#2)!=(byte) 0) goto main::@4 [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a -Statement [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg#0 + (byte) main::i#2) [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a +Statement [32] if(*((const byte[]) main::msg + (byte) main::i#2)!=(byte) 0) goto main::@4 [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a +Statement [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg + (byte) main::i#2) [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a Statement [37] (byte~) utoa10w::$8 ← (byte) utoa10w::i#2 << (byte) 1 [ utoa10w::i#2 utoa10w::value#10 utoa10w::digit#3 utoa10w::bStarted#2 utoa10w::dst#11 utoa10w::$8 ] ( main:2::utoa10w:30 [ utoa10w::i#2 utoa10w::value#10 utoa10w::digit#3 utoa10w::bStarted#2 utoa10w::dst#11 utoa10w::$8 ] ) always clobbers reg byte a Statement [38] if((word) utoa10w::value#10>=*((const word[]) UTOA10_SUB + (byte~) utoa10w::$8)) goto utoa10w::@2 [ utoa10w::i#2 utoa10w::value#10 utoa10w::digit#3 utoa10w::bStarted#2 utoa10w::dst#11 ] ( main:2::utoa10w:30 [ utoa10w::i#2 utoa10w::value#10 utoa10w::digit#3 utoa10w::bStarted#2 utoa10w::dst#11 ] ) always clobbers reg byte a Statement [39] (byte~) utoa10w::$2 ← (byte) utoa10w::i#2 & (byte) 1 [ utoa10w::i#2 utoa10w::value#10 utoa10w::digit#3 utoa10w::bStarted#2 utoa10w::dst#11 utoa10w::$2 ] ( main:2::utoa10w:30 [ utoa10w::i#2 utoa10w::value#10 utoa10w::digit#3 utoa10w::bStarted#2 utoa10w::dst#11 utoa10w::$2 ] ) always clobbers reg byte a @@ -2408,14 +2406,14 @@ main: { jmp b3 // main::@3 b3: - // [32] if(*((const byte[]) main::msg#0 + (byte) main::i#2)!=(byte) 0) goto main::@4 -- pbuc1_derefidx_vbuxx_neq_0_then_la1 + // [32] if(*((const byte[]) main::msg + (byte) main::i#2)!=(byte) 0) goto main::@4 -- pbuc1_derefidx_vbuxx_neq_0_then_la1 lda msg,x cmp #0 bne b4 jmp b1 // main::@4 b4: - // [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg#0 + (byte) main::i#2) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx + // [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg + (byte) main::i#2) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx lda msg,x sta $400+$28+$28+$28+$28+$50+3,x // [34] (byte) main::i#1 ← ++ (byte) main::i#2 -- vbuxx=_inc_vbuxx @@ -2899,8 +2897,7 @@ FINAL SYMBOL TABLE (byte) main::i (byte) main::i#1 reg byte x 202.0 (byte) main::i#2 reg byte x 168.33333333333331 -(byte[]) main::msg -(const byte[]) main::msg#0 msg = (string) "raster lines" +(const byte[]) main::msg msg = (string) "raster lines" (byte) main::rst (byte) main::rst#0 reg byte a 202.0 (byte*) main::screen @@ -3188,7 +3185,7 @@ main: { // main::@3 b3: // for( byte i=0; msg[i]!=0; i++ ) - // [32] if(*((const byte[]) main::msg#0 + (byte) main::i#2)!=(byte) 0) goto main::@4 -- pbuc1_derefidx_vbuxx_neq_0_then_la1 + // [32] if(*((const byte[]) main::msg + (byte) main::i#2)!=(byte) 0) goto main::@4 -- pbuc1_derefidx_vbuxx_neq_0_then_la1 lda msg,x cmp #0 bne b4 @@ -3196,7 +3193,7 @@ main: { // main::@4 b4: // (screen+80+3)[i] = msg[i] - // [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg#0 + (byte) main::i#2) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx + // [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg + (byte) main::i#2) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx lda msg,x sta $400+$28+$28+$28+$28+$50+3,x // for( byte i=0; msg[i]!=0; i++ ) diff --git a/src/test/ref/hex2dec.sym b/src/test/ref/hex2dec.sym index 48210e2c5..212566ad2 100644 --- a/src/test/ref/hex2dec.sym +++ b/src/test/ref/hex2dec.sym @@ -28,8 +28,7 @@ (byte) main::i (byte) main::i#1 reg byte x 202.0 (byte) main::i#2 reg byte x 168.33333333333331 -(byte[]) main::msg -(const byte[]) main::msg#0 msg = (string) "raster lines" +(const byte[]) main::msg msg = (string) "raster lines" (byte) main::rst (byte) main::rst#0 reg byte a 202.0 (byte*) main::screen diff --git a/src/test/ref/pointer-cast-2.cfg b/src/test/ref/pointer-cast-2.cfg index c70037464..a647738d1 100644 --- a/src/test/ref/pointer-cast-2.cfg +++ b/src/test/ref/pointer-cast-2.cfg @@ -12,10 +12,10 @@ main: scope:[main] from @1 [4] (byte) main::ub#0 ← (byte) $ff [5] *((const signed byte*) main::sb_ptr#0) ← (signed byte) 1 - [6] *((const byte*) main::ub_screen#0) ← (byte) main::ub#0 + [6] *((const byte*) main::ub_screen) ← (byte) main::ub#0 [7] (signed byte) main::sb#0 ← (signed byte) $7f [8] *((const byte*) main::ub_ptr#0) ← (byte) 1 - [9] *((const signed byte*) main::sb_screen#0) ← (signed byte) main::sb#0 + [9] *((const signed byte*) main::sb_screen) ← (signed byte) main::sb#0 to:main::@return main::@return: scope:[main] from main [10] return diff --git a/src/test/ref/pointer-cast-2.log b/src/test/ref/pointer-cast-2.log index 81eea8c50..0c712a0bd 100644 --- a/src/test/ref/pointer-cast-2.log +++ b/src/test/ref/pointer-cast-2.log @@ -7,21 +7,21 @@ CONTROL FLOW GRAPH SSA (void()) main() main: scope:[main] from @1 - (byte*) main::ub_screen#0 ← ((byte*)) (number) $400 + (byte*) main::ub_screen ← ((byte*)) (number) $400 (byte) main::ub#0 ← (number) $ff (byte*~) main::$0 ← & (byte) main::ub#0 (signed byte*~) main::$1 ← ((signed byte*)) (byte*~) main::$0 (signed byte*) main::sb_ptr#0 ← (signed byte*~) main::$1 *((signed byte*) main::sb_ptr#0) ← (number) 1 - *((byte*) main::ub_screen#0) ← (byte) main::ub#0 - (signed byte*) main::sb_screen#0 ← ((signed byte*)) (number) $428 + *((byte*) main::ub_screen) ← (byte) main::ub#0 + (signed byte*) main::sb_screen ← ((signed byte*)) (number) $428 (signed byte~) main::$2 ← ((signed byte)) (number) $7f (signed byte) main::sb#0 ← (signed byte~) main::$2 (signed byte*~) main::$3 ← & (signed byte) main::sb#0 (byte*~) main::$4 ← ((byte*)) (signed byte*~) main::$3 (byte*) main::ub_ptr#0 ← (byte*~) main::$4 *((byte*) main::ub_ptr#0) ← (number) 1 - *((signed byte*) main::sb_screen#0) ← (signed byte) main::sb#0 + *((signed byte*) main::sb_screen) ← (signed byte) main::sb#0 to:main::@return main::@return: scope:[main] from main return @@ -50,23 +50,21 @@ SYMBOL TABLE SSA (signed byte*) main::sb_ptr (signed byte*) main::sb_ptr#0 (signed byte*) main::sb_screen -(signed byte*) main::sb_screen#0 (byte) main::ub (byte) main::ub#0 (byte*) main::ub_ptr (byte*) main::ub_ptr#0 (byte*) main::ub_screen -(byte*) main::ub_screen#0 Adding number conversion cast (unumber) $ff in (byte) main::ub#0 ← (number) $ff Adding number conversion cast (snumber) 1 in *((signed byte*) main::sb_ptr#0) ← (number) 1 Adding number conversion cast (unumber) 1 in *((byte*) main::ub_ptr#0) ← (number) 1 Successful SSA optimization PassNAddNumberTypeConversions -Inlining cast (byte*) main::ub_screen#0 ← (byte*)(number) $400 +Inlining cast (byte*) main::ub_screen ← (byte*)(number) $400 Inlining cast (byte) main::ub#0 ← (unumber)(number) $ff Inlining cast (signed byte*~) main::$1 ← (signed byte*)(byte*~) main::$0 Inlining cast *((signed byte*) main::sb_ptr#0) ← (snumber)(number) 1 -Inlining cast (signed byte*) main::sb_screen#0 ← (signed byte*)(number) $428 +Inlining cast (signed byte*) main::sb_screen ← (signed byte*)(number) $428 Inlining cast (signed byte~) main::$2 ← (signed byte)(number) $7f Inlining cast (byte*~) main::$4 ← (byte*)(signed byte*~) main::$3 Inlining cast *((byte*) main::ub_ptr#0) ← (unumber)(number) 1 @@ -90,9 +88,9 @@ Alias candidate removed (volatile)(signed byte) main::sb#0 = (signed byte~) main Constant right-side identified [2] (byte*~) main::$0 ← & (byte) main::ub#0 Constant right-side identified [10] (signed byte*~) main::$3 ← & (signed byte) main::sb#0 Successful SSA optimization Pass2ConstantRValueConsolidation -Constant (const byte*) main::ub_screen#0 = (byte*) 1024 +Constant (const byte*) main::ub_screen = (byte*) 1024 Constant (const byte*) main::$0 = &main::ub#0 -Constant (const signed byte*) main::sb_screen#0 = (signed byte*) 1064 +Constant (const signed byte*) main::sb_screen = (signed byte*) 1064 Constant (const signed byte) main::$2 = $7f Constant (const signed byte*) main::$3 = &main::sb#0 Successful SSA optimization Pass2ConstantIdentification @@ -135,10 +133,10 @@ FINAL CONTROL FLOW GRAPH main: scope:[main] from @1 [4] (byte) main::ub#0 ← (byte) $ff [5] *((const signed byte*) main::sb_ptr#0) ← (signed byte) 1 - [6] *((const byte*) main::ub_screen#0) ← (byte) main::ub#0 + [6] *((const byte*) main::ub_screen) ← (byte) main::ub#0 [7] (signed byte) main::sb#0 ← (signed byte) $7f [8] *((const byte*) main::ub_ptr#0) ← (byte) 1 - [9] *((const signed byte*) main::sb_screen#0) ← (signed byte) main::sb#0 + [9] *((const signed byte*) main::sb_screen) ← (signed byte) main::sb#0 to:main::@return main::@return: scope:[main] from main [10] return @@ -150,11 +148,9 @@ VARIABLE REGISTER WEIGHTS (signed byte) main::sb (signed byte) main::sb#0 2.0 (signed byte*) main::sb_ptr -(signed byte*) main::sb_screen (byte) main::ub (byte) main::ub#0 2.0 (byte*) main::ub_ptr -(byte*) main::ub_screen Initial phi equivalence classes Complete equivalence classes @@ -200,7 +196,7 @@ main: { // [5] *((const signed byte*) main::sb_ptr#0) ← (signed byte) 1 -- _deref_pbsc1=vbsc2 lda #1 sta.z sb_ptr - // [6] *((const byte*) main::ub_screen#0) ← (byte) main::ub#0 -- _deref_pbuc1=vbuz1 + // [6] *((const byte*) main::ub_screen) ← (byte) main::ub#0 -- _deref_pbuc1=vbuz1 lda.z ub sta ub_screen // [7] (signed byte) main::sb#0 ← (signed byte) $7f -- vbsz1=vbsc1 @@ -209,7 +205,7 @@ main: { // [8] *((const byte*) main::ub_ptr#0) ← (byte) 1 -- _deref_pbuc1=vbuc2 lda #1 sta.z ub_ptr - // [9] *((const signed byte*) main::sb_screen#0) ← (signed byte) main::sb#0 -- _deref_pbsc1=vbsz1 + // [9] *((const signed byte*) main::sb_screen) ← (signed byte) main::sb#0 -- _deref_pbsc1=vbsz1 lda.z sb sta sb_screen jmp breturn @@ -223,10 +219,10 @@ main: { REGISTER UPLIFT POTENTIAL REGISTERS Statement [4] (byte) main::ub#0 ← (byte) $ff [ main::ub#0 ] ( main:2 [ main::ub#0 ] ) always clobbers reg byte a Statement [5] *((const signed byte*) main::sb_ptr#0) ← (signed byte) 1 [ main::ub#0 ] ( main:2 [ main::ub#0 ] ) always clobbers reg byte a -Statement [6] *((const byte*) main::ub_screen#0) ← (byte) main::ub#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [6] *((const byte*) main::ub_screen) ← (byte) main::ub#0 [ ] ( main:2 [ ] ) always clobbers reg byte a Statement [7] (signed byte) main::sb#0 ← (signed byte) $7f [ main::sb#0 ] ( main:2 [ main::sb#0 ] ) always clobbers reg byte a Statement [8] *((const byte*) main::ub_ptr#0) ← (byte) 1 [ main::sb#0 ] ( main:2 [ main::sb#0 ] ) always clobbers reg byte a -Statement [9] *((const signed byte*) main::sb_screen#0) ← (signed byte) main::sb#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [9] *((const signed byte*) main::sb_screen) ← (signed byte) main::sb#0 [ ] ( main:2 [ ] ) always clobbers reg byte a Potential registers zp ZP_BYTE:2 [ main::ub#0 ] : zp ZP_BYTE:2 , Potential registers zp ZP_BYTE:3 [ main::sb#0 ] : zp ZP_BYTE:3 , @@ -277,7 +273,7 @@ main: { // [5] *((const signed byte*) main::sb_ptr#0) ← (signed byte) 1 -- _deref_pbsc1=vbsc2 lda #1 sta.z sb_ptr - // [6] *((const byte*) main::ub_screen#0) ← (byte) main::ub#0 -- _deref_pbuc1=vbuz1 + // [6] *((const byte*) main::ub_screen) ← (byte) main::ub#0 -- _deref_pbuc1=vbuz1 lda.z ub sta ub_screen // [7] (signed byte) main::sb#0 ← (signed byte) $7f -- vbsz1=vbsc1 @@ -286,7 +282,7 @@ main: { // [8] *((const byte*) main::ub_ptr#0) ← (byte) 1 -- _deref_pbuc1=vbuc2 lda #1 sta.z ub_ptr - // [9] *((const signed byte*) main::sb_screen#0) ← (signed byte) main::sb#0 -- _deref_pbsc1=vbsz1 + // [9] *((const signed byte*) main::sb_screen) ← (signed byte) main::sb#0 -- _deref_pbsc1=vbsz1 lda.z sb sta sb_screen jmp breturn @@ -325,14 +321,12 @@ FINAL SYMBOL TABLE (signed byte) main::sb#0 sb zp ZP_BYTE:3 2.0 (signed byte*) main::sb_ptr (const signed byte*) main::sb_ptr#0 sb_ptr = (signed byte*)&(byte) main::ub#0 -(signed byte*) main::sb_screen -(const signed byte*) main::sb_screen#0 sb_screen = (signed byte*) 1064 +(const signed byte*) main::sb_screen sb_screen = (signed byte*) 1064 (byte) main::ub (byte) main::ub#0 ub zp ZP_BYTE:2 2.0 (byte*) main::ub_ptr (const byte*) main::ub_ptr#0 ub_ptr = (byte*)&(signed byte) main::sb#0 -(byte*) main::ub_screen -(const byte*) main::ub_screen#0 ub_screen = (byte*) 1024 +(const byte*) main::ub_screen ub_screen = (byte*) 1024 zp ZP_BYTE:2 [ main::ub#0 ] zp ZP_BYTE:3 [ main::sb#0 ] @@ -371,7 +365,7 @@ main: { lda #1 sta.z sb_ptr // *ub_screen = ub - // [6] *((const byte*) main::ub_screen#0) ← (byte) main::ub#0 -- _deref_pbuc1=vbuz1 + // [6] *((const byte*) main::ub_screen) ← (byte) main::ub#0 -- _deref_pbuc1=vbuz1 lda.z ub sta ub_screen // sb = (signed byte)0x7f @@ -383,7 +377,7 @@ main: { lda #1 sta.z ub_ptr // *sb_screen = sb - // [9] *((const signed byte*) main::sb_screen#0) ← (signed byte) main::sb#0 -- _deref_pbsc1=vbsz1 + // [9] *((const signed byte*) main::sb_screen) ← (signed byte) main::sb#0 -- _deref_pbsc1=vbsz1 lda.z sb sta sb_screen // main::@return diff --git a/src/test/ref/pointer-cast-2.sym b/src/test/ref/pointer-cast-2.sym index 5b8781fab..94d7d2e51 100644 --- a/src/test/ref/pointer-cast-2.sym +++ b/src/test/ref/pointer-cast-2.sym @@ -7,14 +7,12 @@ (signed byte) main::sb#0 sb zp ZP_BYTE:3 2.0 (signed byte*) main::sb_ptr (const signed byte*) main::sb_ptr#0 sb_ptr = (signed byte*)&(byte) main::ub#0 -(signed byte*) main::sb_screen -(const signed byte*) main::sb_screen#0 sb_screen = (signed byte*) 1064 +(const signed byte*) main::sb_screen sb_screen = (signed byte*) 1064 (byte) main::ub (byte) main::ub#0 ub zp ZP_BYTE:2 2.0 (byte*) main::ub_ptr (const byte*) main::ub_ptr#0 ub_ptr = (byte*)&(signed byte) main::sb#0 -(byte*) main::ub_screen -(const byte*) main::ub_screen#0 ub_screen = (byte*) 1024 +(const byte*) main::ub_screen ub_screen = (byte*) 1024 zp ZP_BYTE:2 [ main::ub#0 ] zp ZP_BYTE:3 [ main::sb#0 ] diff --git a/src/test/ref/screen-show-spiral-buckets.cfg b/src/test/ref/screen-show-spiral-buckets.cfg index ad39b92ee..b2afc247e 100644 --- a/src/test/ref/screen-show-spiral-buckets.cfg +++ b/src/test/ref/screen-show-spiral-buckets.cfg @@ -57,7 +57,7 @@ main::@2: scope:[main] from main::@1 main::@2 main::@3: scope:[main] from main::@2 [25] *((const byte*) BORDERCOL) ← ++ *((const byte*) BORDERCOL) [26] (byte~) main::$26 ← (byte) main::bucket_idx#6 << (byte) 1 - [27] (word[]) main::bucket#0 ← *((word*[])(void*) BUCKETS + (byte~) main::$26) + [27] (word[]) main::bucket ← *((word*[])(void*) BUCKETS + (byte~) main::$26) [28] (byte) main::bucket_size#0 ← *((byte[])(void*) BUCKET_SIZES + (byte) main::bucket_idx#6) [29] if((byte) main::bucket_size#0<=(byte) 0) goto main::@4 to:main::@5 @@ -90,7 +90,7 @@ main::@12: scope:[main] from main::@4 to:main::@1 main::@6: scope:[main] from main::@5 [41] (byte~) main::$27 ← (byte) main::i#2 << (byte) 1 - [42] (word) main::offset#0 ← *((word[]) main::bucket#0 + (byte~) main::$27) + [42] (word) main::offset#0 ← *((word[]) main::bucket + (byte~) main::$27) [43] (byte*) main::fill#0 ← (const byte*) SCREEN_FILL + (word) main::offset#0 [44] if(*((byte*) main::fill#0)==(const byte) FILL_CHAR) goto main::@18 to:main::@9 diff --git a/src/test/ref/screen-show-spiral-buckets.log b/src/test/ref/screen-show-spiral-buckets.log index 0e7541469..21f48905c 100644 --- a/src/test/ref/screen-show-spiral-buckets.log +++ b/src/test/ref/screen-show-spiral-buckets.log @@ -602,7 +602,7 @@ main::@5: scope:[main] from main::@4 (byte) main::bucket_idx#2 ← phi( main::@4/(byte) main::bucket_idx#4 ) *((byte*) BORDERCOL) ← ++ *((byte*) BORDERCOL) (byte~) main::$26 ← (byte) main::bucket_idx#2 * (const byte) SIZEOF_POINTER - (word[]) main::bucket#0 ← *((word*[]) BUCKETS + (byte~) main::$26) + (word[]) main::bucket ← *((word*[]) BUCKETS + (byte~) main::$26) (byte) main::bucket_size#0 ← *((byte[]) BUCKET_SIZES + (byte) main::bucket_idx#2) (bool~) main::$5 ← (byte) main::bucket_size#0 > (number) 0 (bool~) main::$6 ← ! (bool~) main::$5 @@ -650,7 +650,7 @@ main::@9: scope:[main] from main::@8 (byte) main::min_angle#3 ← phi( main::@8/(byte) main::min_angle#4 ) (byte) main::i#3 ← phi( main::@8/(byte) main::i#2 ) (byte~) main::$27 ← (byte) main::i#3 * (const byte) SIZEOF_WORD - (word) main::offset#0 ← *((word[]) main::bucket#0 + (byte~) main::$27) + (word) main::offset#0 ← *((word[]) main::bucket + (byte~) main::$27) (byte*~) main::$8 ← (byte*) SCREEN_FILL + (word) main::offset#0 (byte*) main::fill#0 ← (byte*~) main::$8 (bool~) main::$9 ← *((byte*) main::fill#0) != (byte) FILL_CHAR @@ -2071,7 +2071,6 @@ SYMBOL TABLE SSA (byte*) main::angle#0 (byte*) main::angle#1 (word[]) main::bucket -(word[]) main::bucket#0 (byte) main::bucket_idx (byte) main::bucket_idx#0 (byte) main::bucket_idx#1 @@ -3438,7 +3437,7 @@ main::@2: scope:[main] from main::@1 main::@2 main::@3: scope:[main] from main::@2 [25] *((const byte*) BORDERCOL) ← ++ *((const byte*) BORDERCOL) [26] (byte~) main::$26 ← (byte) main::bucket_idx#6 << (byte) 1 - [27] (word[]) main::bucket#0 ← *((word*[])(void*) BUCKETS + (byte~) main::$26) + [27] (word[]) main::bucket ← *((word*[])(void*) BUCKETS + (byte~) main::$26) [28] (byte) main::bucket_size#0 ← *((byte[])(void*) BUCKET_SIZES + (byte) main::bucket_idx#6) [29] if((byte) main::bucket_size#0<=(byte) 0) goto main::@4 to:main::@5 @@ -3471,7 +3470,7 @@ main::@12: scope:[main] from main::@4 to:main::@1 main::@6: scope:[main] from main::@5 [41] (byte~) main::$27 ← (byte) main::i#2 << (byte) 1 - [42] (word) main::offset#0 ← *((word[]) main::bucket#0 + (byte~) main::$27) + [42] (word) main::offset#0 ← *((word[]) main::bucket + (byte~) main::$27) [43] (byte*) main::fill#0 ← (const byte*) SCREEN_FILL + (word) main::offset#0 [44] if(*((byte*) main::fill#0)==(const byte) FILL_CHAR) goto main::@18 to:main::@9 @@ -4117,8 +4116,7 @@ VARIABLE REGISTER WEIGHTS (byte~) main::$27 202.0 (byte*) main::angle (byte*) main::angle#0 151.5 -(word[]) main::bucket -(word[]) main::bucket#0 6.588235294117648 +(word[]) main::bucket 6.588235294117648 (byte) main::bucket_idx (byte) main::bucket_idx#1 11.0 (byte) main::bucket_idx#6 2.64 @@ -4221,7 +4219,7 @@ Added variable BUCKET_IDX to zero page equivalence class [ BUCKET_IDX ] Added variable init_angle_screen::screen#0 to zero page equivalence class [ init_angle_screen::screen#0 ] Added variable init_buckets::screen#0 to zero page equivalence class [ init_buckets::screen#0 ] Added variable main::$26 to zero page equivalence class [ main::$26 ] -Added variable main::bucket#0 to zero page equivalence class [ main::bucket#0 ] +Added variable main::bucket to zero page equivalence class [ main::bucket ] Added variable main::bucket_size#0 to zero page equivalence class [ main::bucket_size#0 ] Added variable main::fill1#0 to zero page equivalence class [ main::fill1#0 ] Added variable main::$27 to zero page equivalence class [ main::$27 ] @@ -4329,7 +4327,7 @@ Complete equivalence classes [ init_angle_screen::screen#0 ] [ init_buckets::screen#0 ] [ main::$26 ] -[ main::bucket#0 ] +[ main::bucket ] [ main::bucket_size#0 ] [ main::fill1#0 ] [ main::$27 ] @@ -4436,7 +4434,7 @@ Allocated zp ZP_WORD:72 [ BUCKET_IDX ] Allocated zp ZP_WORD:74 [ init_angle_screen::screen#0 ] Allocated zp ZP_WORD:76 [ init_buckets::screen#0 ] Allocated zp ZP_BYTE:78 [ main::$26 ] -Allocated zp ZP_WORD:79 [ main::bucket#0 ] +Allocated zp ZP_WORD:79 [ main::bucket ] Allocated zp ZP_BYTE:81 [ main::bucket_size#0 ] Allocated zp ZP_WORD:82 [ main::fill1#0 ] Allocated zp ZP_BYTE:84 [ main::$27 ] @@ -4658,9 +4656,9 @@ bend_from_b3: bend: // main main: { + .label bucket = $4f .label _26 = $4e .label _27 = $54 - .label bucket = $4f .label bucket_size = $51 .label bucket_idx = 2 .label offset = 7 @@ -4730,7 +4728,7 @@ main: { lda.z bucket_idx asl sta.z _26 - // [27] (word[]) main::bucket#0 ← *((word*[])(void*) BUCKETS + (byte~) main::$26) -- pwuz1=pptz2_derefidx_vbuz3 + // [27] (word[]) main::bucket ← *((word*[])(void*) BUCKETS + (byte~) main::$26) -- pwuz1=pptz2_derefidx_vbuz3 ldy.z _26 lda (BUCKETS),y sta.z bucket @@ -4828,7 +4826,7 @@ main: { lda.z i asl sta.z _27 - // [42] (word) main::offset#0 ← *((word[]) main::bucket#0 + (byte~) main::$27) -- vwuz1=pwuz2_derefidx_vbuz3 + // [42] (word) main::offset#0 ← *((word[]) main::bucket + (byte~) main::$27) -- vwuz1=pwuz2_derefidx_vbuz3 ldy.z _27 lda (bucket),y sta.z offset @@ -6386,28 +6384,28 @@ Statement [21] (byte*) init_buckets::screen#0 ← (byte[])(void*) SCREEN_DIST [ Statement [24] if(*((const byte*) RASTER)!=(byte) $ff) goto main::@2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp ZP_BYTE:2 [ main::bucket_idx#6 main::bucket_idx#1 ] Statement [26] (byte~) main::$26 ← (byte) main::bucket_idx#6 << (byte) 1 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::$26 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::$26 ] ) always clobbers reg byte a -Statement [27] (word[]) main::bucket#0 ← *((word*[])(void*) BUCKETS + (byte~) main::$26) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 ] ) always clobbers reg byte a reg byte y +Statement [27] (word[]) main::bucket ← *((word*[])(void*) BUCKETS + (byte~) main::$26) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket ] ) always clobbers reg byte a reg byte y Removing always clobbered register reg byte y as potential for zp ZP_BYTE:2 [ main::bucket_idx#6 main::bucket_idx#1 ] -Statement [28] (byte) main::bucket_size#0 ← *((byte[])(void*) BUCKET_SIZES + (byte) main::bucket_idx#6) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 ] ) always clobbers reg byte a reg byte y +Statement [28] (byte) main::bucket_size#0 ← *((byte[])(void*) BUCKET_SIZES + (byte) main::bucket_idx#6) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 ] ) always clobbers reg byte a reg byte y Statement [32] if((word) main::min_offset#2==(word) $ffff) goto main::@4 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::min_offset#2 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::min_offset#2 ] ) always clobbers reg byte a Statement [33] (byte*) main::fill1#0 ← (const byte*) SCREEN_FILL + (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::fill1#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::fill1#0 ] ) always clobbers reg byte a Statement [34] *((byte*) main::fill1#0) ← (const byte) FILL_CHAR [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ) always clobbers reg byte a reg byte y -Statement [41] (byte~) main::$27 ← (byte) main::i#2 << (byte) 1 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ) always clobbers reg byte a +Statement [41] (byte~) main::$27 ← (byte) main::i#2 << (byte) 1 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp ZP_BYTE:81 [ main::bucket_size#0 ] Removing always clobbered register reg byte a as potential for zp ZP_BYTE:3 [ main::i#2 main::i#1 ] Removing always clobbered register reg byte a as potential for zp ZP_BYTE:6 [ main::min_angle#2 main::min_angle#5 main::min_angle#1 ] -Statement [42] (word) main::offset#0 ← *((word[]) main::bucket#0 + (byte~) main::$27) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y +Statement [42] (word) main::offset#0 ← *((word[]) main::bucket + (byte~) main::$27) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y Removing always clobbered register reg byte y as potential for zp ZP_BYTE:81 [ main::bucket_size#0 ] Removing always clobbered register reg byte y as potential for zp ZP_BYTE:3 [ main::i#2 main::i#1 ] Removing always clobbered register reg byte y as potential for zp ZP_BYTE:6 [ main::min_angle#2 main::min_angle#5 main::min_angle#1 ] -Statement [43] (byte*) main::fill#0 ← (const byte*) SCREEN_FILL + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ) always clobbers reg byte a -Statement [44] if(*((byte*) main::fill#0)==(const byte) FILL_CHAR) goto main::@18 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y -Statement [45] (byte*) main::angle#0 ← (byte[])(void*) SCREEN_ANGLE + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a -Statement [46] if(*((byte*) main::angle#0)>(byte) main::min_angle#2) goto main::@17 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a reg byte y -Statement [47] (byte) main::min_angle#1 ← *((byte*) main::angle#0) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ) always clobbers reg byte a reg byte y -Statement [50] (word~) main::min_offset#8 ← (word) main::min_offset#5 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ) always clobbers reg byte a -Statement [51] (word~) main::min_offset#9 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ) always clobbers reg byte a -Statement [52] (word~) main::min_offset#11 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ) always clobbers reg byte a +Statement [43] (byte*) main::fill#0 ← (const byte*) SCREEN_FILL + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ) always clobbers reg byte a +Statement [44] if(*((byte*) main::fill#0)==(const byte) FILL_CHAR) goto main::@18 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y +Statement [45] (byte*) main::angle#0 ← (byte[])(void*) SCREEN_ANGLE + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a +Statement [46] if(*((byte*) main::angle#0)>(byte) main::min_angle#2) goto main::@17 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a reg byte y +Statement [47] (byte) main::min_angle#1 ← *((byte*) main::angle#0) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ) always clobbers reg byte a reg byte y +Statement [50] (word~) main::min_offset#8 ← (word) main::min_offset#5 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ) always clobbers reg byte a +Statement [51] (word~) main::min_offset#9 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ) always clobbers reg byte a +Statement [52] (word~) main::min_offset#11 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ) always clobbers reg byte a Statement [55] *((byte[])(void*) BUCKET_SIZES + (byte) init_buckets::i#2) ← (byte) 0 [ BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::i#2 heap_head#1 ] ( main:14::init_buckets:22 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::i#2 heap_head#1 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp ZP_BYTE:9 [ init_buckets::i#2 init_buckets::i#1 ] Statement [58] (byte*~) init_buckets::dist#6 ← (byte*) init_buckets::screen#0 [ BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::dist#6 heap_head#1 ] ( main:14::init_buckets:22 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::dist#6 heap_head#1 ] ) always clobbers reg byte a @@ -6554,21 +6552,21 @@ Statement [19] (byte*) init_angle_screen::screen#0 ← (byte[])(void*) SCREEN_AN Statement [21] (byte*) init_buckets::screen#0 ← (byte[])(void*) SCREEN_DIST [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 heap_head#1 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 heap_head#1 ] ) always clobbers reg byte a Statement [24] if(*((const byte*) RASTER)!=(byte) $ff) goto main::@2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ) always clobbers reg byte a Statement [26] (byte~) main::$26 ← (byte) main::bucket_idx#6 << (byte) 1 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::$26 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::$26 ] ) always clobbers reg byte a -Statement [27] (word[]) main::bucket#0 ← *((word*[])(void*) BUCKETS + (byte~) main::$26) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 ] ) always clobbers reg byte a reg byte y -Statement [28] (byte) main::bucket_size#0 ← *((byte[])(void*) BUCKET_SIZES + (byte) main::bucket_idx#6) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 ] ) always clobbers reg byte a reg byte y +Statement [27] (word[]) main::bucket ← *((word*[])(void*) BUCKETS + (byte~) main::$26) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket ] ) always clobbers reg byte a reg byte y +Statement [28] (byte) main::bucket_size#0 ← *((byte[])(void*) BUCKET_SIZES + (byte) main::bucket_idx#6) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 ] ) always clobbers reg byte a reg byte y Statement [32] if((word) main::min_offset#2==(word) $ffff) goto main::@4 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::min_offset#2 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::min_offset#2 ] ) always clobbers reg byte a Statement [33] (byte*) main::fill1#0 ← (const byte*) SCREEN_FILL + (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::fill1#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::fill1#0 ] ) always clobbers reg byte a Statement [34] *((byte*) main::fill1#0) ← (const byte) FILL_CHAR [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ) always clobbers reg byte a reg byte y -Statement [41] (byte~) main::$27 ← (byte) main::i#2 << (byte) 1 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ) always clobbers reg byte a -Statement [42] (word) main::offset#0 ← *((word[]) main::bucket#0 + (byte~) main::$27) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y -Statement [43] (byte*) main::fill#0 ← (const byte*) SCREEN_FILL + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ) always clobbers reg byte a -Statement [44] if(*((byte*) main::fill#0)==(const byte) FILL_CHAR) goto main::@18 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y -Statement [45] (byte*) main::angle#0 ← (byte[])(void*) SCREEN_ANGLE + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a -Statement [46] if(*((byte*) main::angle#0)>(byte) main::min_angle#2) goto main::@17 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a reg byte y -Statement [47] (byte) main::min_angle#1 ← *((byte*) main::angle#0) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ) always clobbers reg byte a reg byte y -Statement [50] (word~) main::min_offset#8 ← (word) main::min_offset#5 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ) always clobbers reg byte a -Statement [51] (word~) main::min_offset#9 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ) always clobbers reg byte a -Statement [52] (word~) main::min_offset#11 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ) always clobbers reg byte a +Statement [41] (byte~) main::$27 ← (byte) main::i#2 << (byte) 1 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ) always clobbers reg byte a +Statement [42] (word) main::offset#0 ← *((word[]) main::bucket + (byte~) main::$27) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y +Statement [43] (byte*) main::fill#0 ← (const byte*) SCREEN_FILL + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ) always clobbers reg byte a +Statement [44] if(*((byte*) main::fill#0)==(const byte) FILL_CHAR) goto main::@18 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y +Statement [45] (byte*) main::angle#0 ← (byte[])(void*) SCREEN_ANGLE + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a +Statement [46] if(*((byte*) main::angle#0)>(byte) main::min_angle#2) goto main::@17 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a reg byte y +Statement [47] (byte) main::min_angle#1 ← *((byte*) main::angle#0) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ) always clobbers reg byte a reg byte y +Statement [50] (word~) main::min_offset#8 ← (word) main::min_offset#5 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ) always clobbers reg byte a +Statement [51] (word~) main::min_offset#9 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ) always clobbers reg byte a +Statement [52] (word~) main::min_offset#11 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ) always clobbers reg byte a Statement [55] *((byte[])(void*) BUCKET_SIZES + (byte) init_buckets::i#2) ← (byte) 0 [ BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::i#2 heap_head#1 ] ( main:14::init_buckets:22 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::i#2 heap_head#1 ] ) always clobbers reg byte a Statement [58] (byte*~) init_buckets::dist#6 ← (byte*) init_buckets::screen#0 [ BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::dist#6 heap_head#1 ] ( main:14::init_buckets:22 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::dist#6 heap_head#1 ] ) always clobbers reg byte a Statement [60] *((byte[])(void*) BUCKET_SIZES + *((byte*) init_buckets::dist#4)) ← ++ *((byte[])(void*) BUCKET_SIZES + *((byte*) init_buckets::dist#4)) [ BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::dist#4 init_buckets::i1#2 heap_head#1 ] ( main:14::init_buckets:22 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::dist#4 init_buckets::i1#2 heap_head#1 ] ) always clobbers reg byte a reg byte y @@ -6696,21 +6694,21 @@ Statement [19] (byte*) init_angle_screen::screen#0 ← (byte[])(void*) SCREEN_AN Statement [21] (byte*) init_buckets::screen#0 ← (byte[])(void*) SCREEN_DIST [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 heap_head#1 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 heap_head#1 ] ) always clobbers reg byte a Statement [24] if(*((const byte*) RASTER)!=(byte) $ff) goto main::@2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ) always clobbers reg byte a Statement [26] (byte~) main::$26 ← (byte) main::bucket_idx#6 << (byte) 1 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::$26 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::$26 ] ) always clobbers reg byte a -Statement [27] (word[]) main::bucket#0 ← *((word*[])(void*) BUCKETS + (byte~) main::$26) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 ] ) always clobbers reg byte a reg byte y -Statement [28] (byte) main::bucket_size#0 ← *((byte[])(void*) BUCKET_SIZES + (byte) main::bucket_idx#6) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 ] ) always clobbers reg byte a reg byte y +Statement [27] (word[]) main::bucket ← *((word*[])(void*) BUCKETS + (byte~) main::$26) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket ] ) always clobbers reg byte a reg byte y +Statement [28] (byte) main::bucket_size#0 ← *((byte[])(void*) BUCKET_SIZES + (byte) main::bucket_idx#6) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 ] ) always clobbers reg byte a reg byte y Statement [32] if((word) main::min_offset#2==(word) $ffff) goto main::@4 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::min_offset#2 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::min_offset#2 ] ) always clobbers reg byte a Statement [33] (byte*) main::fill1#0 ← (const byte*) SCREEN_FILL + (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::fill1#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::fill1#0 ] ) always clobbers reg byte a Statement [34] *((byte*) main::fill1#0) ← (const byte) FILL_CHAR [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ) always clobbers reg byte a reg byte y -Statement [41] (byte~) main::$27 ← (byte) main::i#2 << (byte) 1 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ) always clobbers reg byte a -Statement [42] (word) main::offset#0 ← *((word[]) main::bucket#0 + (byte~) main::$27) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y -Statement [43] (byte*) main::fill#0 ← (const byte*) SCREEN_FILL + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ) always clobbers reg byte a -Statement [44] if(*((byte*) main::fill#0)==(const byte) FILL_CHAR) goto main::@18 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y -Statement [45] (byte*) main::angle#0 ← (byte[])(void*) SCREEN_ANGLE + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a -Statement [46] if(*((byte*) main::angle#0)>(byte) main::min_angle#2) goto main::@17 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a reg byte y -Statement [47] (byte) main::min_angle#1 ← *((byte*) main::angle#0) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ) always clobbers reg byte a reg byte y -Statement [50] (word~) main::min_offset#8 ← (word) main::min_offset#5 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ) always clobbers reg byte a -Statement [51] (word~) main::min_offset#9 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ) always clobbers reg byte a -Statement [52] (word~) main::min_offset#11 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ) always clobbers reg byte a +Statement [41] (byte~) main::$27 ← (byte) main::i#2 << (byte) 1 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ) always clobbers reg byte a +Statement [42] (word) main::offset#0 ← *((word[]) main::bucket + (byte~) main::$27) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y +Statement [43] (byte*) main::fill#0 ← (const byte*) SCREEN_FILL + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ) always clobbers reg byte a +Statement [44] if(*((byte*) main::fill#0)==(const byte) FILL_CHAR) goto main::@18 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y +Statement [45] (byte*) main::angle#0 ← (byte[])(void*) SCREEN_ANGLE + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a +Statement [46] if(*((byte*) main::angle#0)>(byte) main::min_angle#2) goto main::@17 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a reg byte y +Statement [47] (byte) main::min_angle#1 ← *((byte*) main::angle#0) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ) always clobbers reg byte a reg byte y +Statement [50] (word~) main::min_offset#8 ← (word) main::min_offset#5 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ) always clobbers reg byte a +Statement [51] (word~) main::min_offset#9 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ) always clobbers reg byte a +Statement [52] (word~) main::min_offset#11 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ) always clobbers reg byte a Statement [55] *((byte[])(void*) BUCKET_SIZES + (byte) init_buckets::i#2) ← (byte) 0 [ BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::i#2 heap_head#1 ] ( main:14::init_buckets:22 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::i#2 heap_head#1 ] ) always clobbers reg byte a Statement [58] (byte*~) init_buckets::dist#6 ← (byte*) init_buckets::screen#0 [ BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::dist#6 heap_head#1 ] ( main:14::init_buckets:22 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::dist#6 heap_head#1 ] ) always clobbers reg byte a Statement [60] *((byte[])(void*) BUCKET_SIZES + *((byte*) init_buckets::dist#4)) ← ++ *((byte[])(void*) BUCKET_SIZES + *((byte*) init_buckets::dist#4)) [ BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::dist#4 init_buckets::i1#2 heap_head#1 ] ( main:14::init_buckets:22 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::dist#4 init_buckets::i1#2 heap_head#1 ] ) always clobbers reg byte a reg byte y @@ -6875,7 +6873,7 @@ Potential registers zp ZP_WORD:72 [ BUCKET_IDX ] : zp ZP_WORD:72 , Potential registers zp ZP_WORD:74 [ init_angle_screen::screen#0 ] : zp ZP_WORD:74 , Potential registers zp ZP_WORD:76 [ init_buckets::screen#0 ] : zp ZP_WORD:76 , Potential registers zp ZP_BYTE:78 [ main::$26 ] : zp ZP_BYTE:78 , reg byte a , reg byte x , reg byte y , -Potential registers zp ZP_WORD:79 [ main::bucket#0 ] : zp ZP_WORD:79 , +Potential registers zp ZP_WORD:79 [ main::bucket ] : zp ZP_WORD:79 , Potential registers zp ZP_BYTE:81 [ main::bucket_size#0 ] : zp ZP_BYTE:81 , reg byte x , Potential registers zp ZP_WORD:82 [ main::fill1#0 ] : zp ZP_WORD:82 , Potential registers zp ZP_BYTE:84 [ main::$27 ] : zp ZP_BYTE:84 , reg byte a , reg byte x , reg byte y , @@ -6939,7 +6937,7 @@ REGISTER UPLIFT SCOPES Uplift Scope [atan2_16] 28,670.58: zp ZP_BYTE:41 [ atan2_16::shift#2 atan2_16::shift#5 atan2_16::shift#1 ] 20,608: zp ZP_WORD:42 [ atan2_16::yd#5 atan2_16::yd#3 atan2_16::yd#10 atan2_16::yd#1 atan2_16::yd#2 ] 17,338.67: zp ZP_WORD:44 [ atan2_16::xd#5 atan2_16::xd#3 atan2_16::xd#10 atan2_16::xd#1 atan2_16::xd#2 ] 7,533.33: zp ZP_WORD:37 [ atan2_16::angle#6 atan2_16::angle#12 atan2_16::angle#13 atan2_16::angle#2 atan2_16::angle#3 ] 2,698.28: zp ZP_WORD:32 [ atan2_16::yi#3 atan2_16::yi#8 atan2_16::yi#0 atan2_16::yi#16 atan2_16::$2 atan2_16::yi#1 atan2_16::yi#2 ] 2,283.07: zp ZP_WORD:34 [ atan2_16::xi#3 atan2_16::xi#8 atan2_16::xi#0 atan2_16::xi#13 atan2_16::$7 atan2_16::xi#1 atan2_16::xi#2 ] 2,002: zp ZP_BYTE:132 [ atan2_16::$24 ] 2,002: zp ZP_BYTE:133 [ atan2_16::$23 ] 1,710.04: zp ZP_BYTE:36 [ atan2_16::i#2 atan2_16::i#1 ] 202: zp ZP_WORD:122 [ atan2_16::return#2 ] 50: zp ZP_WORD:39 [ atan2_16::return#0 atan2_16::angle#5 atan2_16::angle#11 atan2_16::angle#1 atan2_16::angle#4 ] 2.87: zp ZP_WORD:118 [ atan2_16::x#0 ] 2.72: zp ZP_WORD:120 [ atan2_16::y#0 ] Uplift Scope [bsearch16u] 7,563.11: zp ZP_BYTE:57 [ bsearch16u::num#5 bsearch16u::num#1 bsearch16u::num#3 bsearch16u::num#0 ] 2,855.06: zp ZP_WORD:55 [ bsearch16u::return#1 bsearch16u::return#6 bsearch16u::return#2 bsearch16u::items#2 bsearch16u::items#1 bsearch16u::items#8 bsearch16u::$2 bsearch16u::items#0 ] 2,002: zp ZP_BYTE:161 [ bsearch16u::$6 ] 2,002: zp ZP_BYTE:162 [ bsearch16u::$16 ] 1,501.5: zp ZP_WORD:165 [ bsearch16u::result#0 ] 501: zp ZP_WORD:163 [ bsearch16u::pivot#0 ] 4: zp ZP_WORD:152 [ bsearch16u::return#3 ] 0.27: zp ZP_WORD:150 [ bsearch16u::key#0 ] Uplift Scope [init_angle_screen] 220.36: zp ZP_BYTE:31 [ init_angle_screen::xb#2 init_angle_screen::xb#1 ] 202: zp ZP_BYTE:111 [ init_angle_screen::$3 ] 202: zp ZP_BYTE:112 [ init_angle_screen::$4 ] 202: zp ZP_BYTE:115 [ init_angle_screen::$7 ] 202: zp ZP_WORD:124 [ init_angle_screen::angle_w#0 ] 202: zp ZP_WORD:126 [ init_angle_screen::$11 ] 202: zp ZP_BYTE:129 [ init_angle_screen::$13 ] 202: zp ZP_BYTE:130 [ init_angle_screen::$14 ] 202: zp ZP_BYTE:131 [ init_angle_screen::$15 ] 129.86: zp ZP_BYTE:30 [ init_angle_screen::x#2 init_angle_screen::x#1 ] 84.17: zp ZP_BYTE:128 [ init_angle_screen::ang_w#0 ] 50.5: zp ZP_WORD:116 [ init_angle_screen::yw#0 ] 33.67: zp ZP_WORD:113 [ init_angle_screen::xw#0 ] 21.23: zp ZP_BYTE:25 [ init_angle_screen::y#5 init_angle_screen::y#1 ] 20.37: zp ZP_WORD:28 [ init_angle_screen::screen_bottomline#6 init_angle_screen::screen_bottomline#0 init_angle_screen::screen_bottomline#1 ] 16.92: zp ZP_WORD:26 [ init_angle_screen::screen_topline#6 init_angle_screen::screen_topline#0 init_angle_screen::screen_topline#1 ] 3: zp ZP_WORD:74 [ init_angle_screen::screen#0 ] -Uplift Scope [main] 673.33: zp ZP_WORD:7 [ main::min_offset#5 main::min_offset#9 main::offset#0 main::min_offset#11 ] 377.07: zp ZP_BYTE:6 [ main::min_angle#2 main::min_angle#5 main::min_angle#1 ] 238.11: zp ZP_WORD:4 [ main::min_offset#2 main::min_offset#8 ] 202: zp ZP_BYTE:84 [ main::$27 ] 202: zp ZP_WORD:85 [ main::fill#0 ] 151.5: zp ZP_WORD:87 [ main::angle#0 ] 134.67: zp ZP_BYTE:3 [ main::i#2 main::i#1 ] 22: zp ZP_BYTE:78 [ main::$26 ] 22: zp ZP_WORD:82 [ main::fill1#0 ] 13.64: zp ZP_BYTE:2 [ main::bucket_idx#6 main::bucket_idx#1 ] 7.69: zp ZP_BYTE:81 [ main::bucket_size#0 ] 6.59: zp ZP_WORD:79 [ main::bucket#0 ] +Uplift Scope [main] 673.33: zp ZP_WORD:7 [ main::min_offset#5 main::min_offset#9 main::offset#0 main::min_offset#11 ] 377.07: zp ZP_BYTE:6 [ main::min_angle#2 main::min_angle#5 main::min_angle#1 ] 238.11: zp ZP_WORD:4 [ main::min_offset#2 main::min_offset#8 ] 202: zp ZP_BYTE:84 [ main::$27 ] 202: zp ZP_WORD:85 [ main::fill#0 ] 151.5: zp ZP_WORD:87 [ main::angle#0 ] 134.67: zp ZP_BYTE:3 [ main::i#2 main::i#1 ] 22: zp ZP_BYTE:78 [ main::$26 ] 22: zp ZP_WORD:82 [ main::fill1#0 ] 13.64: zp ZP_BYTE:2 [ main::bucket_idx#6 main::bucket_idx#1 ] 7.69: zp ZP_BYTE:81 [ main::bucket_size#0 ] 6.59: zp ZP_WORD:79 [ main::bucket ] Uplift Scope [init_dist_screen] 707: zp ZP_BYTE:54 [ init_dist_screen::xd#0 init_dist_screen::$16 init_dist_screen::$14 ] 221.24: zp ZP_BYTE:53 [ init_dist_screen::xb#2 init_dist_screen::xb#1 ] 202: zp ZP_BYTE:139 [ init_dist_screen::x2#0 ] 202: zp ZP_WORD:142 [ init_dist_screen::xds#0 ] 202: zp ZP_WORD:144 [ init_dist_screen::ds#0 ] 131.3: zp ZP_BYTE:52 [ init_dist_screen::x#2 init_dist_screen::x#1 ] 126.25: zp ZP_BYTE:149 [ init_dist_screen::d#0 ] 77: zp ZP_BYTE:51 [ init_dist_screen::yd#0 init_dist_screen::$7 init_dist_screen::$5 ] 22: zp ZP_BYTE:134 [ init_dist_screen::y2#0 ] 18.18: zp ZP_WORD:49 [ init_dist_screen::screen_bottomline#11 init_dist_screen::screen_bottomline#0 init_dist_screen::screen_bottomline#1 ] 17.47: zp ZP_BYTE:46 [ init_dist_screen::y#10 init_dist_screen::y#1 ] 14.06: zp ZP_WORD:47 [ init_dist_screen::screen_topline#11 init_dist_screen::screen#0 init_dist_screen::screen_topline#1 ] 4.87: zp ZP_WORD:137 [ init_dist_screen::yds#0 ] Uplift Scope [sqr] 338: zp ZP_BYTE:58 [ sqr::val#2 sqr::val#1 sqr::val#0 ] 202: zp ZP_WORD:140 [ sqr::return#3 ] 28.5: zp ZP_WORD:168 [ sqr::return#0 ] 22: zp ZP_WORD:135 [ sqr::return#2 ] 4: zp ZP_BYTE:167 [ sqr::$0 ] Uplift Scope [init_buckets] 34.33: zp ZP_WORD:10 [ init_buckets::dist#4 init_buckets::dist#6 init_buckets::dist#1 ] 33: zp ZP_BYTE:9 [ init_buckets::i#2 init_buckets::i#1 ] 33: zp ZP_BYTE:16 [ init_buckets::i3#2 init_buckets::i3#1 ] 23.83: zp ZP_WORD:12 [ init_buckets::i1#2 init_buckets::i1#1 ] 22: zp ZP_WORD:14 [ init_buckets::i2#2 init_buckets::i2#1 ] 22: zp ZP_WORD:89 [ init_buckets::$18 ] 22: zp ZP_WORD:93 [ init_buckets::$15 ] 22: zp ZP_WORD:95 [ init_buckets::$19 ] 22: zp ZP_WORD:98 [ init_buckets::$10 ] 22: zp ZP_WORD:100 [ init_buckets::$16 ] 22: zp ZP_WORD:102 [ init_buckets::$20 ] 22: zp ZP_BYTE:108 [ init_buckets::$17 ] 18.5: zp ZP_WORD:19 [ init_buckets::i4#2 init_buckets::i4#1 ] 15.93: zp ZP_WORD:17 [ init_buckets::dist#5 init_buckets::dist#8 init_buckets::dist#3 ] 11: zp ZP_WORD:106 [ init_buckets::$11 ] 7.33: zp ZP_WORD:104 [ init_buckets::bucket#0 ] 5.5: zp ZP_BYTE:97 [ init_buckets::distance#0 ] 3.67: zp ZP_WORD:91 [ init_buckets::$6 ] 0.43: zp ZP_WORD:76 [ init_buckets::screen#0 ] @@ -6954,7 +6952,7 @@ Limited combination testing to 100 combinations of 144 possible. Uplifting [bsearch16u] best 1234979 combination reg byte x [ bsearch16u::num#5 bsearch16u::num#1 bsearch16u::num#3 bsearch16u::num#0 ] zp ZP_WORD:55 [ bsearch16u::return#1 bsearch16u::return#6 bsearch16u::return#2 bsearch16u::items#2 bsearch16u::items#1 bsearch16u::items#8 bsearch16u::$2 bsearch16u::items#0 ] reg byte a [ bsearch16u::$6 ] reg byte a [ bsearch16u::$16 ] zp ZP_WORD:165 [ bsearch16u::result#0 ] zp ZP_WORD:163 [ bsearch16u::pivot#0 ] zp ZP_WORD:152 [ bsearch16u::return#3 ] zp ZP_WORD:150 [ bsearch16u::key#0 ] Uplifting [init_angle_screen] best 1233379 combination zp ZP_BYTE:31 [ init_angle_screen::xb#2 init_angle_screen::xb#1 ] reg byte a [ init_angle_screen::$3 ] reg byte a [ init_angle_screen::$4 ] reg byte a [ init_angle_screen::$7 ] zp ZP_WORD:124 [ init_angle_screen::angle_w#0 ] zp ZP_WORD:126 [ init_angle_screen::$11 ] zp ZP_BYTE:129 [ init_angle_screen::$13 ] zp ZP_BYTE:130 [ init_angle_screen::$14 ] zp ZP_BYTE:131 [ init_angle_screen::$15 ] zp ZP_BYTE:30 [ init_angle_screen::x#2 init_angle_screen::x#1 ] zp ZP_BYTE:128 [ init_angle_screen::ang_w#0 ] zp ZP_WORD:116 [ init_angle_screen::yw#0 ] zp ZP_WORD:113 [ init_angle_screen::xw#0 ] zp ZP_BYTE:25 [ init_angle_screen::y#5 init_angle_screen::y#1 ] zp ZP_WORD:28 [ init_angle_screen::screen_bottomline#6 init_angle_screen::screen_bottomline#0 init_angle_screen::screen_bottomline#1 ] zp ZP_WORD:26 [ init_angle_screen::screen_topline#6 init_angle_screen::screen_topline#0 init_angle_screen::screen_topline#1 ] zp ZP_WORD:74 [ init_angle_screen::screen#0 ] Limited combination testing to 100 combinations of 65536 possible. -Uplifting [main] best 1231939 combination zp ZP_WORD:7 [ main::min_offset#5 main::min_offset#9 main::offset#0 main::min_offset#11 ] zp ZP_BYTE:6 [ main::min_angle#2 main::min_angle#5 main::min_angle#1 ] zp ZP_WORD:4 [ main::min_offset#2 main::min_offset#8 ] reg byte a [ main::$27 ] zp ZP_WORD:85 [ main::fill#0 ] zp ZP_WORD:87 [ main::angle#0 ] reg byte x [ main::i#2 main::i#1 ] reg byte a [ main::$26 ] zp ZP_WORD:82 [ main::fill1#0 ] zp ZP_BYTE:2 [ main::bucket_idx#6 main::bucket_idx#1 ] zp ZP_BYTE:81 [ main::bucket_size#0 ] zp ZP_WORD:79 [ main::bucket#0 ] +Uplifting [main] best 1231939 combination zp ZP_WORD:7 [ main::min_offset#5 main::min_offset#9 main::offset#0 main::min_offset#11 ] zp ZP_BYTE:6 [ main::min_angle#2 main::min_angle#5 main::min_angle#1 ] zp ZP_WORD:4 [ main::min_offset#2 main::min_offset#8 ] reg byte a [ main::$27 ] zp ZP_WORD:85 [ main::fill#0 ] zp ZP_WORD:87 [ main::angle#0 ] reg byte x [ main::i#2 main::i#1 ] reg byte a [ main::$26 ] zp ZP_WORD:82 [ main::fill1#0 ] zp ZP_BYTE:2 [ main::bucket_idx#6 main::bucket_idx#1 ] zp ZP_BYTE:81 [ main::bucket_size#0 ] zp ZP_WORD:79 [ main::bucket ] Limited combination testing to 100 combinations of 256 possible. Uplifting [init_dist_screen] best 1228739 combination reg byte a [ init_dist_screen::xd#0 init_dist_screen::$16 init_dist_screen::$14 ] zp ZP_BYTE:53 [ init_dist_screen::xb#2 init_dist_screen::xb#1 ] reg byte a [ init_dist_screen::x2#0 ] zp ZP_WORD:142 [ init_dist_screen::xds#0 ] zp ZP_WORD:144 [ init_dist_screen::ds#0 ] zp ZP_BYTE:52 [ init_dist_screen::x#2 init_dist_screen::x#1 ] reg byte a [ init_dist_screen::d#0 ] zp ZP_BYTE:51 [ init_dist_screen::yd#0 init_dist_screen::$7 init_dist_screen::$5 ] zp ZP_BYTE:134 [ init_dist_screen::y2#0 ] zp ZP_WORD:49 [ init_dist_screen::screen_bottomline#11 init_dist_screen::screen_bottomline#0 init_dist_screen::screen_bottomline#1 ] zp ZP_BYTE:46 [ init_dist_screen::y#10 init_dist_screen::y#1 ] zp ZP_WORD:47 [ init_dist_screen::screen_topline#11 init_dist_screen::screen#0 init_dist_screen::screen_topline#1 ] zp ZP_WORD:137 [ init_dist_screen::yds#0 ] Limited combination testing to 100 combinations of 6144 possible. @@ -7037,7 +7035,7 @@ Coalescing zero page register [ zp ZP_WORD:47 [ init_dist_screen::screen_topline Coalescing zero page register [ zp ZP_WORD:49 [ init_dist_screen::screen_bottomline#11 init_dist_screen::screen_bottomline#0 init_dist_screen::screen_bottomline#1 ] ] with [ zp ZP_WORD:37 [ atan2_16::angle#6 atan2_16::angle#12 atan2_16::angle#13 atan2_16::angle#2 atan2_16::angle#3 atan2_16::return#0 atan2_16::angle#5 atan2_16::angle#11 atan2_16::angle#1 atan2_16::angle#4 atan2_16::return#2 init_angle_screen::angle_w#0 init_angle_screen::$11 ] ] Coalescing zero page register [ zp ZP_WORD:55 [ bsearch16u::return#1 bsearch16u::return#6 bsearch16u::return#2 bsearch16u::items#2 bsearch16u::items#1 bsearch16u::items#8 bsearch16u::$2 bsearch16u::items#0 bsearch16u::return#3 sqrt::found#0 sqrt::$3 sqrt::$1 ] ] with [ zp ZP_WORD:42 [ atan2_16::yd#5 atan2_16::yd#3 atan2_16::yd#10 atan2_16::yd#1 atan2_16::yd#2 ] ] Coalescing zero page register [ zp ZP_WORD:59 [ init_squares::sqr#2 init_squares::sqr#1 ] ] with [ zp ZP_WORD:44 [ atan2_16::xd#5 atan2_16::xd#3 atan2_16::xd#10 atan2_16::xd#1 atan2_16::xd#2 ] ] -Coalescing zero page register [ zp ZP_WORD:79 [ main::bucket#0 ] ] with [ zp ZP_WORD:61 [ init_squares::squares#2 init_squares::squares#1 init_squares::squares#0 ] ] +Coalescing zero page register [ zp ZP_WORD:79 [ main::bucket ] ] with [ zp ZP_WORD:61 [ init_squares::squares#2 init_squares::squares#1 init_squares::squares#0 ] ] Coalescing zero page register [ zp ZP_BYTE:81 [ main::bucket_size#0 ] ] with [ zp ZP_BYTE:52 [ init_dist_screen::x#2 init_dist_screen::x#1 ] ] Coalescing zero page register [ zp ZP_WORD:85 [ main::fill#0 ] ] with [ zp ZP_WORD:64 [ SCREEN_DIST init_buckets::screen#0 ] ] Coalescing zero page register [ zp ZP_WORD:87 [ main::angle#0 ] ] with [ zp ZP_WORD:72 [ BUCKET_IDX ] ] @@ -7047,7 +7045,7 @@ Coalescing zero page register [ zp ZP_WORD:116 [ init_angle_screen::yw#0 atan2_1 Coalescing zero page register [ zp ZP_WORD:135 [ sqr::return#2 init_dist_screen::yds#0 ] ] with [ zp ZP_WORD:106 [ init_buckets::$11 ] ] Coalescing zero page register [ zp ZP_WORD:47 [ init_dist_screen::screen_topline#11 init_dist_screen::screen#0 init_dist_screen::screen_topline#1 atan2_16::xi#3 atan2_16::xi#8 atan2_16::xi#0 atan2_16::xi#13 atan2_16::$7 atan2_16::xi#1 atan2_16::xi#2 ] ] with [ zp ZP_WORD:10 [ init_buckets::dist#4 init_buckets::dist#6 init_buckets::dist#1 main::min_offset#2 main::min_offset#8 main::fill1#0 ] ] Coalescing zero page register [ zp ZP_WORD:49 [ init_dist_screen::screen_bottomline#11 init_dist_screen::screen_bottomline#0 init_dist_screen::screen_bottomline#1 atan2_16::angle#6 atan2_16::angle#12 atan2_16::angle#13 atan2_16::angle#2 atan2_16::angle#3 atan2_16::return#0 atan2_16::angle#5 atan2_16::angle#11 atan2_16::angle#1 atan2_16::angle#4 atan2_16::return#2 init_angle_screen::angle_w#0 init_angle_screen::$11 ] ] with [ zp ZP_WORD:12 [ init_buckets::i1#2 init_buckets::i1#1 main::min_offset#5 main::min_offset#9 main::offset#0 main::min_offset#11 ] ] -Coalescing zero page register [ zp ZP_WORD:79 [ main::bucket#0 init_squares::squares#2 init_squares::squares#1 init_squares::squares#0 ] ] with [ zp ZP_WORD:26 [ init_angle_screen::screen_topline#6 init_angle_screen::screen_topline#0 init_angle_screen::screen_topline#1 init_buckets::i2#2 init_buckets::i2#1 ] ] +Coalescing zero page register [ zp ZP_WORD:79 [ main::bucket init_squares::squares#2 init_squares::squares#1 init_squares::squares#0 ] ] with [ zp ZP_WORD:26 [ init_angle_screen::screen_topline#6 init_angle_screen::screen_topline#0 init_angle_screen::screen_topline#1 init_buckets::i2#2 init_buckets::i2#1 ] ] Coalescing zero page register [ zp ZP_BYTE:97 [ init_buckets::distance#0 init_dist_screen::xb#2 init_dist_screen::xb#1 ] ] with [ zp ZP_BYTE:25 [ init_angle_screen::y#5 init_angle_screen::y#1 main::bucket_idx#6 main::bucket_idx#1 ] ] Coalescing zero page register [ zp ZP_BYTE:128 [ init_angle_screen::ang_w#0 ] ] with [ zp ZP_BYTE:81 [ main::bucket_size#0 init_dist_screen::x#2 init_dist_screen::x#1 ] ] Coalescing zero page register [ zp ZP_WORD:135 [ sqr::return#2 init_dist_screen::yds#0 init_buckets::$11 ] ] with [ zp ZP_WORD:59 [ init_squares::sqr#2 init_squares::sqr#1 atan2_16::xd#5 atan2_16::xd#3 atan2_16::xd#10 atan2_16::xd#1 atan2_16::xd#2 ] ] @@ -7064,7 +7062,7 @@ Allocated (was zp ZP_WORD:55) zp ZP_WORD:12 [ bsearch16u::return#1 bsearch16u::r Allocated (was zp ZP_WORD:66) zp ZP_WORD:14 [ SCREEN_ANGLE ] Allocated (was zp ZP_WORD:68) zp ZP_WORD:16 [ BUCKET_SIZES ] Allocated (was zp ZP_WORD:70) zp ZP_WORD:18 [ BUCKETS ] -Allocated (was zp ZP_WORD:79) zp ZP_WORD:20 [ main::bucket#0 init_squares::squares#2 init_squares::squares#1 init_squares::squares#0 init_angle_screen::screen_topline#6 init_angle_screen::screen_topline#0 init_angle_screen::screen_topline#1 init_buckets::i2#2 init_buckets::i2#1 ] +Allocated (was zp ZP_WORD:79) zp ZP_WORD:20 [ main::bucket init_squares::squares#2 init_squares::squares#1 init_squares::squares#0 init_angle_screen::screen_topline#6 init_angle_screen::screen_topline#0 init_angle_screen::screen_topline#1 init_buckets::i2#2 init_buckets::i2#1 ] Allocated (was zp ZP_WORD:85) zp ZP_WORD:22 [ main::fill#0 SCREEN_DIST init_buckets::screen#0 ] Allocated (was zp ZP_WORD:87) zp ZP_WORD:24 [ main::angle#0 BUCKET_IDX ] Allocated (was zp ZP_BYTE:97) zp ZP_BYTE:26 [ init_buckets::distance#0 init_dist_screen::xb#2 init_dist_screen::xb#1 init_angle_screen::y#5 init_angle_screen::y#1 main::bucket_idx#6 main::bucket_idx#1 ] @@ -7299,7 +7297,7 @@ main: { // [26] (byte~) main::$26 ← (byte) main::bucket_idx#6 << (byte) 1 -- vbuaa=vbuz1_rol_1 lda.z bucket_idx asl - // [27] (word[]) main::bucket#0 ← *((word*[])(void*) BUCKETS + (byte~) main::$26) -- pwuz1=pptz2_derefidx_vbuaa + // [27] (word[]) main::bucket ← *((word*[])(void*) BUCKETS + (byte~) main::$26) -- pwuz1=pptz2_derefidx_vbuaa tay lda (BUCKETS),y sta.z bucket @@ -7394,7 +7392,7 @@ main: { // [41] (byte~) main::$27 ← (byte) main::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 txa asl - // [42] (word) main::offset#0 ← *((word[]) main::bucket#0 + (byte~) main::$27) -- vwuz1=pwuz2_derefidx_vbuaa + // [42] (word) main::offset#0 ← *((word[]) main::bucket + (byte~) main::$27) -- vwuz1=pwuz2_derefidx_vbuaa tay lda (bucket),y sta.z offset @@ -9402,8 +9400,7 @@ FINAL SYMBOL TABLE (label) main::@9 (byte*) main::angle (byte*) main::angle#0 angle zp ZP_WORD:24 151.5 -(word[]) main::bucket -(word[]) main::bucket#0 bucket zp ZP_WORD:20 6.588235294117648 +(word[]) main::bucket bucket zp ZP_WORD:20 6.588235294117648 (byte) main::bucket_idx (byte) main::bucket_idx#1 bucket_idx zp ZP_BYTE:26 11.0 (byte) main::bucket_idx#6 bucket_idx zp ZP_BYTE:26 2.64 @@ -9482,7 +9479,7 @@ zp ZP_WORD:14 [ SCREEN_ANGLE ] zp ZP_WORD:16 [ BUCKET_SIZES ] zp ZP_WORD:18 [ BUCKETS ] reg byte a [ main::$26 ] -zp ZP_WORD:20 [ main::bucket#0 init_squares::squares#2 init_squares::squares#1 init_squares::squares#0 init_angle_screen::screen_topline#6 init_angle_screen::screen_topline#0 init_angle_screen::screen_topline#1 init_buckets::i2#2 init_buckets::i2#1 ] +zp ZP_WORD:20 [ main::bucket init_squares::squares#2 init_squares::squares#1 init_squares::squares#0 init_angle_screen::screen_topline#6 init_angle_screen::screen_topline#0 init_angle_screen::screen_topline#1 init_buckets::i2#2 init_buckets::i2#1 ] reg byte a [ main::$27 ] zp ZP_WORD:22 [ main::fill#0 SCREEN_DIST init_buckets::screen#0 ] zp ZP_WORD:24 [ main::angle#0 BUCKET_IDX ] @@ -9718,7 +9715,7 @@ main: { // [26] (byte~) main::$26 ← (byte) main::bucket_idx#6 << (byte) 1 -- vbuaa=vbuz1_rol_1 lda.z bucket_idx asl - // [27] (word[]) main::bucket#0 ← *((word*[])(void*) BUCKETS + (byte~) main::$26) -- pwuz1=pptz2_derefidx_vbuaa + // [27] (word[]) main::bucket ← *((word*[])(void*) BUCKETS + (byte~) main::$26) -- pwuz1=pptz2_derefidx_vbuaa tay lda (BUCKETS),y sta.z bucket @@ -9814,7 +9811,7 @@ main: { // [41] (byte~) main::$27 ← (byte) main::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 txa asl - // [42] (word) main::offset#0 ← *((word[]) main::bucket#0 + (byte~) main::$27) -- vwuz1=pwuz2_derefidx_vbuaa + // [42] (word) main::offset#0 ← *((word[]) main::bucket + (byte~) main::$27) -- vwuz1=pwuz2_derefidx_vbuaa tay lda (bucket),y sta.z offset diff --git a/src/test/ref/screen-show-spiral-buckets.sym b/src/test/ref/screen-show-spiral-buckets.sym index 13f136b09..a0d94cd8a 100644 --- a/src/test/ref/screen-show-spiral-buckets.sym +++ b/src/test/ref/screen-show-spiral-buckets.sym @@ -331,8 +331,7 @@ (label) main::@9 (byte*) main::angle (byte*) main::angle#0 angle zp ZP_WORD:24 151.5 -(word[]) main::bucket -(word[]) main::bucket#0 bucket zp ZP_WORD:20 6.588235294117648 +(word[]) main::bucket bucket zp ZP_WORD:20 6.588235294117648 (byte) main::bucket_idx (byte) main::bucket_idx#1 bucket_idx zp ZP_BYTE:26 11.0 (byte) main::bucket_idx#6 bucket_idx zp ZP_BYTE:26 2.64 @@ -411,7 +410,7 @@ zp ZP_WORD:14 [ SCREEN_ANGLE ] zp ZP_WORD:16 [ BUCKET_SIZES ] zp ZP_WORD:18 [ BUCKETS ] reg byte a [ main::$26 ] -zp ZP_WORD:20 [ main::bucket#0 init_squares::squares#2 init_squares::squares#1 init_squares::squares#0 init_angle_screen::screen_topline#6 init_angle_screen::screen_topline#0 init_angle_screen::screen_topline#1 init_buckets::i2#2 init_buckets::i2#1 ] +zp ZP_WORD:20 [ main::bucket init_squares::squares#2 init_squares::squares#1 init_squares::squares#0 init_angle_screen::screen_topline#6 init_angle_screen::screen_topline#0 init_angle_screen::screen_topline#1 init_buckets::i2#2 init_buckets::i2#1 ] reg byte a [ main::$27 ] zp ZP_WORD:22 [ main::fill#0 SCREEN_DIST init_buckets::screen#0 ] zp ZP_WORD:24 [ main::angle#0 BUCKET_IDX ] diff --git a/src/test/ref/test-comparisons.cfg b/src/test/ref/test-comparisons.cfg index 38224cbc7..c68c81f51 100644 --- a/src/test/ref/test-comparisons.cfg +++ b/src/test/ref/test-comparisons.cfg @@ -44,7 +44,7 @@ main::@3: scope:[main] from main::@23 main::@43 [20] call printu to:main::@44 main::@44: scope:[main] from main::@3 - [21] if((byte) main::a#10>=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@4 + [21] if((byte) main::a#10>=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@4 to:main::@24 main::@24: scope:[main] from main::@44 [22] phi() @@ -52,7 +52,7 @@ main::@24: scope:[main] from main::@44 main::@4: scope:[main] from main::@24 main::@44 [23] (byte) main::r#43 ← phi( main::@24/(byte) '+' main::@44/(byte) '-' ) [24] (byte) printu::a#2 ← (byte) main::a#10 - [25] (byte) printu::b#2 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) + [25] (byte) printu::b#2 ← *((const byte[5]) main::cs + (byte) main::i#10) [26] (byte) printu::res#2 ← (byte) main::r#43 [27] call printu to:main::@45 @@ -100,7 +100,7 @@ main::@7: scope:[main] from main::@27 main::@48 [50] call printu to:main::@49 main::@49: scope:[main] from main::@7 - [51] if((byte) main::a#10<=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@8 + [51] if((byte) main::a#10<=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@8 to:main::@28 main::@28: scope:[main] from main::@49 [52] phi() @@ -108,7 +108,7 @@ main::@28: scope:[main] from main::@49 main::@8: scope:[main] from main::@28 main::@49 [53] (byte) main::r#47 ← phi( main::@28/(byte) '+' main::@49/(byte) '-' ) [54] (byte) printu::a#6 ← (byte) main::a#10 - [55] (byte) printu::b#6 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) + [55] (byte) printu::b#6 ← *((const byte[5]) main::cs + (byte) main::i#10) [56] (byte) printu::res#6 ← (byte) main::r#47 [57] call printu to:main::@50 @@ -156,7 +156,7 @@ main::@11: scope:[main] from main::@31 main::@53 [80] call printu to:main::@54 main::@54: scope:[main] from main::@11 - [81] if((byte) main::a#10>*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@12 + [81] if((byte) main::a#10>*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@12 to:main::@32 main::@32: scope:[main] from main::@54 [82] phi() @@ -164,7 +164,7 @@ main::@32: scope:[main] from main::@54 main::@12: scope:[main] from main::@32 main::@54 [83] (byte) main::r#51 ← phi( main::@32/(byte) '+' main::@54/(byte) '-' ) [84] (byte) printu::a#10 ← (byte) main::a#10 - [85] (byte) printu::b#10 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) + [85] (byte) printu::b#10 ← *((const byte[5]) main::cs + (byte) main::i#10) [86] (byte) printu::res#10 ← (byte) main::r#51 [87] call printu to:main::@55 @@ -212,7 +212,7 @@ main::@15: scope:[main] from main::@35 main::@58 [110] call printu to:main::@59 main::@59: scope:[main] from main::@15 - [111] if((byte) main::a#10<*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@16 + [111] if((byte) main::a#10<*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@16 to:main::@36 main::@36: scope:[main] from main::@59 [112] phi() @@ -220,7 +220,7 @@ main::@36: scope:[main] from main::@59 main::@16: scope:[main] from main::@36 main::@59 [113] (byte) main::r#55 ← phi( main::@36/(byte) '+' main::@59/(byte) '-' ) [114] (byte) printu::a#14 ← (byte) main::a#10 - [115] (byte) printu::b#14 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) + [115] (byte) printu::b#14 ← *((const byte[5]) main::cs + (byte) main::i#10) [116] (byte) printu::res#14 ← (byte) main::r#55 [117] call printu to:main::@60 @@ -268,7 +268,7 @@ main::@19: scope:[main] from main::@39 main::@63 [140] call printu to:main::@64 main::@64: scope:[main] from main::@19 - [141] if((byte) main::a#10!=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@20 + [141] if((byte) main::a#10!=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@20 to:main::@40 main::@40: scope:[main] from main::@64 [142] phi() @@ -276,7 +276,7 @@ main::@40: scope:[main] from main::@64 main::@20: scope:[main] from main::@40 main::@64 [143] (byte) main::r#59 ← phi( main::@40/(byte) '+' main::@64/(byte) '-' ) [144] (byte) printu::a#18 ← (byte) main::a#10 - [145] (byte) printu::b#18 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) + [145] (byte) printu::b#18 ← *((const byte[5]) main::cs + (byte) main::i#10) [146] (byte) printu::res#18 ← (byte) main::r#59 [147] call printu to:main::@65 diff --git a/src/test/ref/test-comparisons.log b/src/test/ref/test-comparisons.log index fb80a1a68..2db2d6369 100644 --- a/src/test/ref/test-comparisons.log +++ b/src/test/ref/test-comparisons.log @@ -249,7 +249,7 @@ main::@1: scope:[main] from main::@45 main::@70 (byte) main::r#0 ← (byte) 0 (number~) main::$1 ← (number) $ce - (byte) main::a#2 (byte) main::b#0 ← (number~) main::$1 - (byte[5]) main::cs#0 ← { (number) 7, (number) $c7, (number) $37, (number) $97, (number) $67 } + (byte[5]) main::cs ← { (number) 7, (number) $c7, (number) $37, (number) $97, (number) $67 } (byte) main::r#1 ← (byte) '-' (bool~) main::$2 ← (byte) main::a#2 < (byte) main::b#0 (bool~) main::$3 ← ! (bool~) main::$2 @@ -309,7 +309,7 @@ main::@47: scope:[main] from main::@3 (byte*) print_char_cursor#59 ← phi( main::@3/(byte*) print_char_cursor#45 ) (byte*) print_char_cursor#14 ← (byte*) print_char_cursor#59 (byte) main::r#4 ← (byte) '-' - (bool~) main::$8 ← (byte) main::a#6 < *((byte[5]) main::cs#0 + (byte) main::i#2) + (bool~) main::$8 ← (byte) main::a#6 < *((byte[5]) main::cs + (byte) main::i#2) (bool~) main::$9 ← ! (bool~) main::$8 if((bool~) main::$9) goto main::@4 to:main::@24 @@ -330,7 +330,7 @@ main::@4: scope:[main] from main::@24 main::@47 (byte) main::a#7 ← phi( main::@24/(byte) main::a#45 main::@47/(byte) main::a#6 ) (byte) printu::a#2 ← (byte) main::a#7 (byte[]) printu::op#2 ← (const string) main::op2 - (byte) printu::b#2 ← *((byte[5]) main::cs#0 + (byte) main::i#3) + (byte) printu::b#2 ← *((byte[5]) main::cs + (byte) main::i#3) (byte) printu::res#2 ← (byte) main::r#43 call printu to:main::@48 @@ -451,7 +451,7 @@ main::@52: scope:[main] from main::@7 (byte*) print_char_cursor#64 ← phi( main::@7/(byte*) print_char_cursor#45 ) (byte*) print_char_cursor#19 ← (byte*) print_char_cursor#64 (byte) main::r#12 ← (byte) '-' - (bool~) main::$21 ← (byte) main::a#14 > *((byte[5]) main::cs#0 + (byte) main::i#4) + (bool~) main::$21 ← (byte) main::a#14 > *((byte[5]) main::cs + (byte) main::i#4) (bool~) main::$22 ← ! (bool~) main::$21 if((bool~) main::$22) goto main::@8 to:main::@28 @@ -472,7 +472,7 @@ main::@8: scope:[main] from main::@28 main::@52 (byte) main::a#15 ← phi( main::@28/(byte) main::a#50 main::@52/(byte) main::a#14 ) (byte) printu::a#6 ← (byte) main::a#15 (byte[]) printu::op#6 ← (const string) main::op6 - (byte) printu::b#6 ← *((byte[5]) main::cs#0 + (byte) main::i#5) + (byte) printu::b#6 ← *((byte[5]) main::cs + (byte) main::i#5) (byte) printu::res#6 ← (byte) main::r#47 call printu to:main::@53 @@ -593,7 +593,7 @@ main::@57: scope:[main] from main::@11 (byte*) print_char_cursor#69 ← phi( main::@11/(byte*) print_char_cursor#45 ) (byte*) print_char_cursor#24 ← (byte*) print_char_cursor#69 (byte) main::r#20 ← (byte) '-' - (bool~) main::$34 ← (byte) main::a#22 <= *((byte[5]) main::cs#0 + (byte) main::i#6) + (bool~) main::$34 ← (byte) main::a#22 <= *((byte[5]) main::cs + (byte) main::i#6) (bool~) main::$35 ← ! (bool~) main::$34 if((bool~) main::$35) goto main::@12 to:main::@32 @@ -614,7 +614,7 @@ main::@12: scope:[main] from main::@32 main::@57 (byte) main::a#23 ← phi( main::@32/(byte) main::a#55 main::@57/(byte) main::a#22 ) (byte) printu::a#10 ← (byte) main::a#23 (byte[]) printu::op#10 ← (const string) main::op10 - (byte) printu::b#10 ← *((byte[5]) main::cs#0 + (byte) main::i#7) + (byte) printu::b#10 ← *((byte[5]) main::cs + (byte) main::i#7) (byte) printu::res#10 ← (byte) main::r#51 call printu to:main::@58 @@ -735,7 +735,7 @@ main::@62: scope:[main] from main::@15 (byte*) print_char_cursor#74 ← phi( main::@15/(byte*) print_char_cursor#45 ) (byte*) print_char_cursor#29 ← (byte*) print_char_cursor#74 (byte) main::r#28 ← (byte) '-' - (bool~) main::$47 ← (byte) main::a#30 >= *((byte[5]) main::cs#0 + (byte) main::i#8) + (bool~) main::$47 ← (byte) main::a#30 >= *((byte[5]) main::cs + (byte) main::i#8) (bool~) main::$48 ← ! (bool~) main::$47 if((bool~) main::$48) goto main::@16 to:main::@36 @@ -756,7 +756,7 @@ main::@16: scope:[main] from main::@36 main::@62 (byte) main::a#31 ← phi( main::@36/(byte) main::a#60 main::@62/(byte) main::a#30 ) (byte) printu::a#14 ← (byte) main::a#31 (byte[]) printu::op#14 ← (const string) main::op14 - (byte) printu::b#14 ← *((byte[5]) main::cs#0 + (byte) main::i#9) + (byte) printu::b#14 ← *((byte[5]) main::cs + (byte) main::i#9) (byte) printu::res#14 ← (byte) main::r#55 call printu to:main::@63 @@ -874,7 +874,7 @@ main::@67: scope:[main] from main::@19 (byte*) print_char_cursor#79 ← phi( main::@19/(byte*) print_char_cursor#45 ) (byte*) print_char_cursor#34 ← (byte*) print_char_cursor#79 (byte) main::r#36 ← (byte) '-' - (bool~) main::$60 ← (byte) main::a#38 == *((byte[5]) main::cs#0 + (byte) main::i#10) + (bool~) main::$60 ← (byte) main::a#38 == *((byte[5]) main::cs + (byte) main::i#10) (bool~) main::$61 ← ! (bool~) main::$60 if((bool~) main::$61) goto main::@20 to:main::@40 @@ -893,7 +893,7 @@ main::@20: scope:[main] from main::@40 main::@67 (byte) main::a#39 ← phi( main::@40/(byte) main::a#65 main::@67/(byte) main::a#38 ) (byte) printu::a#18 ← (byte) main::a#39 (byte[]) printu::op#18 ← (const string) main::op18 - (byte) printu::b#18 ← *((byte[5]) main::cs#0 + (byte) main::i#11) + (byte) printu::b#18 ← *((byte[5]) main::cs + (byte) main::i#11) (byte) printu::res#18 ← (byte) main::r#59 call printu to:main::@68 @@ -1293,7 +1293,6 @@ SYMBOL TABLE SSA (byte) main::b#8 (byte) main::b#9 (byte[5]) main::cs -(byte[5]) main::cs#0 (byte) main::i (byte) main::i#0 (byte) main::i#1 @@ -1901,7 +1900,7 @@ Adding number conversion cast (unumber) $37 in (byte) printu::b#17 ← (number) Adding number conversion cast (unumber) $30 in (number~) main::$67 ← (byte) main::a#42 + (number) $30 Adding number conversion cast (unumber) main::$67 in (number~) main::$67 ← (byte) main::a#42 + (unumber)(number) $30 Successful SSA optimization PassNAddNumberTypeConversions -Added casts to value list in (byte[5]) main::cs#0 ← (byte[5]){ (byte)(number) 7, (byte)(number) $c7, (byte)(number) $37, (byte)(number) $97, (byte)(number) $67 } +Added casts to value list in (byte[5]) main::cs ← (byte[5]){ (byte)(number) 7, (byte)(number) $c7, (byte)(number) $37, (byte)(number) $97, (byte)(number) $67 } Successful SSA optimization PassNAddInitializerValueListTypeCasts Inlining cast (byte*~) memset::$2 ← (byte*)(void*) memset::str#2 Inlining cast (byte*) memset::dst#0 ← (byte*)(void*) memset::str#2 @@ -1966,23 +1965,23 @@ Inferred type updated to byte in (unumber~) main::$67 ← (byte) main::a#42 + (b Inversing boolean not [2] (bool~) memset::$1 ← (word) memset::num#1 <= (byte) 0 from [1] (bool~) memset::$0 ← (word) memset::num#1 > (byte) 0 Inversing boolean not [95] (bool~) main::$3 ← (byte) main::a#2 >= (byte) main::b#0 from [94] (bool~) main::$2 ← (byte) main::a#2 < (byte) main::b#0 Inversing boolean not [107] (bool~) main::$6 ← (byte) main::a#4 >= (byte) $37 from [106] (bool~) main::$5 ← (byte) main::a#4 < (byte) $37 -Inversing boolean not [121] (bool~) main::$9 ← (byte) main::a#6 >= *((byte[5]) main::cs#0 + (byte) main::i#2) from [120] (bool~) main::$8 ← (byte) main::a#6 < *((byte[5]) main::cs#0 + (byte) main::i#2) +Inversing boolean not [121] (bool~) main::$9 ← (byte) main::a#6 >= *((byte[5]) main::cs + (byte) main::i#2) from [120] (bool~) main::$8 ← (byte) main::a#6 < *((byte[5]) main::cs + (byte) main::i#2) Inversing boolean not [135] (bool~) main::$12 ← (byte) main::a#8 >= (byte) main::a#8 from [134] (bool~) main::$11 ← (byte) main::a#8 < (byte) main::a#8 Inversing boolean not [153] (bool~) main::$16 ← (byte) main::a#10 <= (byte) main::b#2 from [152] (bool~) main::$15 ← (byte) main::a#10 > (byte) main::b#2 Inversing boolean not [167] (bool~) main::$19 ← (byte) main::a#12 <= (byte) $37 from [166] (bool~) main::$18 ← (byte) main::a#12 > (byte) $37 -Inversing boolean not [181] (bool~) main::$22 ← (byte) main::a#14 <= *((byte[5]) main::cs#0 + (byte) main::i#4) from [180] (bool~) main::$21 ← (byte) main::a#14 > *((byte[5]) main::cs#0 + (byte) main::i#4) +Inversing boolean not [181] (bool~) main::$22 ← (byte) main::a#14 <= *((byte[5]) main::cs + (byte) main::i#4) from [180] (bool~) main::$21 ← (byte) main::a#14 > *((byte[5]) main::cs + (byte) main::i#4) Inversing boolean not [195] (bool~) main::$25 ← (byte) main::a#16 <= (byte) main::a#16 from [194] (bool~) main::$24 ← (byte) main::a#16 > (byte) main::a#16 Inversing boolean not [213] (bool~) main::$29 ← (byte) main::a#18 > (byte) main::b#4 from [212] (bool~) main::$28 ← (byte) main::a#18 <= (byte) main::b#4 Inversing boolean not [227] (bool~) main::$32 ← (byte) main::a#20 > (byte) $37 from [226] (bool~) main::$31 ← (byte) main::a#20 <= (byte) $37 -Inversing boolean not [241] (bool~) main::$35 ← (byte) main::a#22 > *((byte[5]) main::cs#0 + (byte) main::i#6) from [240] (bool~) main::$34 ← (byte) main::a#22 <= *((byte[5]) main::cs#0 + (byte) main::i#6) +Inversing boolean not [241] (bool~) main::$35 ← (byte) main::a#22 > *((byte[5]) main::cs + (byte) main::i#6) from [240] (bool~) main::$34 ← (byte) main::a#22 <= *((byte[5]) main::cs + (byte) main::i#6) Inversing boolean not [255] (bool~) main::$38 ← (byte) main::a#24 > (byte) main::a#24 from [254] (bool~) main::$37 ← (byte) main::a#24 <= (byte) main::a#24 Inversing boolean not [273] (bool~) main::$42 ← (byte) main::a#26 < (byte) main::b#6 from [272] (bool~) main::$41 ← (byte) main::a#26 >= (byte) main::b#6 Inversing boolean not [287] (bool~) main::$45 ← (byte) main::a#28 < (byte) $37 from [286] (bool~) main::$44 ← (byte) main::a#28 >= (byte) $37 -Inversing boolean not [301] (bool~) main::$48 ← (byte) main::a#30 < *((byte[5]) main::cs#0 + (byte) main::i#8) from [300] (bool~) main::$47 ← (byte) main::a#30 >= *((byte[5]) main::cs#0 + (byte) main::i#8) +Inversing boolean not [301] (bool~) main::$48 ← (byte) main::a#30 < *((byte[5]) main::cs + (byte) main::i#8) from [300] (bool~) main::$47 ← (byte) main::a#30 >= *((byte[5]) main::cs + (byte) main::i#8) Inversing boolean not [315] (bool~) main::$51 ← (byte) main::a#32 < (byte) main::a#32 from [314] (bool~) main::$50 ← (byte) main::a#32 >= (byte) main::a#32 Inversing boolean not [333] (bool~) main::$55 ← (byte) main::a#34 != (byte) main::b#8 from [332] (bool~) main::$54 ← (byte) main::a#34 == (byte) main::b#8 Inversing boolean not [347] (bool~) main::$58 ← (byte) main::a#36 != (byte) $37 from [346] (bool~) main::$57 ← (byte) main::a#36 == (byte) $37 -Inversing boolean not [361] (bool~) main::$61 ← (byte) main::a#38 != *((byte[5]) main::cs#0 + (byte) main::i#10) from [360] (bool~) main::$60 ← (byte) main::a#38 == *((byte[5]) main::cs#0 + (byte) main::i#10) +Inversing boolean not [361] (bool~) main::$61 ← (byte) main::a#38 != *((byte[5]) main::cs + (byte) main::i#10) from [360] (bool~) main::$60 ← (byte) main::a#38 == *((byte[5]) main::cs + (byte) main::i#10) Inversing boolean not [375] (bool~) main::$64 ← (byte) main::a#40 != (byte) main::a#40 from [374] (bool~) main::$63 ← (byte) main::a#40 == (byte) main::a#40 Successful SSA optimization Pass2UnaryNotSimplification Alias (void*) memset::return#0 = (void*) memset::str#1 (void*) memset::return#3 (void*) memset::return#1 @@ -2228,23 +2227,23 @@ Simple Condition (bool~) print_str::$0 [26] if((byte) 0!=*((byte*) print_str::st Simple Condition (bool~) print_ln::$1 [39] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#55) goto print_ln::@1 Simple Condition (bool~) main::$3 [96] if((byte) main::a#10>=(byte) main::b#0) goto main::@2 Simple Condition (bool~) main::$6 [108] if((byte) main::a#10>=(byte) $37) goto main::@3 -Simple Condition (bool~) main::$9 [122] if((byte) main::a#10>=*((byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@4 +Simple Condition (bool~) main::$9 [122] if((byte) main::a#10>=*((byte[5]) main::cs + (byte) main::i#10)) goto main::@4 Simple Condition (bool~) main::$12 [136] if((byte) main::a#10>=(byte) main::a#10) goto main::@5 Simple Condition (bool~) main::$16 [154] if((byte) main::a#10<=(byte) main::b#0) goto main::@6 Simple Condition (bool~) main::$19 [168] if((byte) main::a#10<=(byte) $37) goto main::@7 -Simple Condition (bool~) main::$22 [182] if((byte) main::a#10<=*((byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@8 +Simple Condition (bool~) main::$22 [182] if((byte) main::a#10<=*((byte[5]) main::cs + (byte) main::i#10)) goto main::@8 Simple Condition (bool~) main::$25 [196] if((byte) main::a#10<=(byte) main::a#10) goto main::@9 Simple Condition (bool~) main::$29 [214] if((byte) main::a#10>(byte) main::b#0) goto main::@10 Simple Condition (bool~) main::$32 [228] if((byte) main::a#10>(byte) $37) goto main::@11 -Simple Condition (bool~) main::$35 [242] if((byte) main::a#10>*((byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@12 +Simple Condition (bool~) main::$35 [242] if((byte) main::a#10>*((byte[5]) main::cs + (byte) main::i#10)) goto main::@12 Simple Condition (bool~) main::$38 [256] if((byte) main::a#10>(byte) main::a#10) goto main::@13 Simple Condition (bool~) main::$42 [274] if((byte) main::a#10<(byte) main::b#0) goto main::@14 Simple Condition (bool~) main::$45 [288] if((byte) main::a#10<(byte) $37) goto main::@15 -Simple Condition (bool~) main::$48 [302] if((byte) main::a#10<*((byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@16 +Simple Condition (bool~) main::$48 [302] if((byte) main::a#10<*((byte[5]) main::cs + (byte) main::i#10)) goto main::@16 Simple Condition (bool~) main::$51 [316] if((byte) main::a#10<(byte) main::a#10) goto main::@17 Simple Condition (bool~) main::$55 [334] if((byte) main::a#10!=(byte) main::b#0) goto main::@18 Simple Condition (bool~) main::$58 [348] if((byte) main::a#10!=(byte) $37) goto main::@19 -Simple Condition (bool~) main::$61 [362] if((byte) main::a#10!=*((byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@20 +Simple Condition (bool~) main::$61 [362] if((byte) main::a#10!=*((byte[5]) main::cs + (byte) main::i#10)) goto main::@20 Simple Condition (bool~) main::$64 [376] if((byte) main::a#10!=(byte) main::a#10) goto main::@21 Simple Condition (bool~) main::$68 [395] if((byte) main::i#1!=rangelast(0,4)) goto main::@1 Successful SSA optimization Pass2ConditionalJumpSimplification @@ -2257,7 +2256,7 @@ Constant (const word) memset::num#0 = $3e8 Constant (const byte) main::a#0 = 7 Constant (const byte) main::i#0 = 0 Constant (const byte) main::r#0 = 0 -Constant (const byte[5]) main::cs#0 = { 7, $c7, $37, $97, $67 } +Constant (const byte[5]) main::cs = { 7, $c7, $37, $97, $67 } Constant (const byte) main::r#1 = '-' Constant (const byte[]) printu::op#0 = main::op Constant (const byte) main::r#2 = '-' @@ -2803,7 +2802,7 @@ main::@3: scope:[main] from main::@23 main::@43 [20] call printu to:main::@44 main::@44: scope:[main] from main::@3 - [21] if((byte) main::a#10>=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@4 + [21] if((byte) main::a#10>=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@4 to:main::@24 main::@24: scope:[main] from main::@44 [22] phi() @@ -2811,7 +2810,7 @@ main::@24: scope:[main] from main::@44 main::@4: scope:[main] from main::@24 main::@44 [23] (byte) main::r#43 ← phi( main::@24/(byte) '+' main::@44/(byte) '-' ) [24] (byte) printu::a#2 ← (byte) main::a#10 - [25] (byte) printu::b#2 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) + [25] (byte) printu::b#2 ← *((const byte[5]) main::cs + (byte) main::i#10) [26] (byte) printu::res#2 ← (byte) main::r#43 [27] call printu to:main::@45 @@ -2859,7 +2858,7 @@ main::@7: scope:[main] from main::@27 main::@48 [50] call printu to:main::@49 main::@49: scope:[main] from main::@7 - [51] if((byte) main::a#10<=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@8 + [51] if((byte) main::a#10<=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@8 to:main::@28 main::@28: scope:[main] from main::@49 [52] phi() @@ -2867,7 +2866,7 @@ main::@28: scope:[main] from main::@49 main::@8: scope:[main] from main::@28 main::@49 [53] (byte) main::r#47 ← phi( main::@28/(byte) '+' main::@49/(byte) '-' ) [54] (byte) printu::a#6 ← (byte) main::a#10 - [55] (byte) printu::b#6 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) + [55] (byte) printu::b#6 ← *((const byte[5]) main::cs + (byte) main::i#10) [56] (byte) printu::res#6 ← (byte) main::r#47 [57] call printu to:main::@50 @@ -2915,7 +2914,7 @@ main::@11: scope:[main] from main::@31 main::@53 [80] call printu to:main::@54 main::@54: scope:[main] from main::@11 - [81] if((byte) main::a#10>*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@12 + [81] if((byte) main::a#10>*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@12 to:main::@32 main::@32: scope:[main] from main::@54 [82] phi() @@ -2923,7 +2922,7 @@ main::@32: scope:[main] from main::@54 main::@12: scope:[main] from main::@32 main::@54 [83] (byte) main::r#51 ← phi( main::@32/(byte) '+' main::@54/(byte) '-' ) [84] (byte) printu::a#10 ← (byte) main::a#10 - [85] (byte) printu::b#10 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) + [85] (byte) printu::b#10 ← *((const byte[5]) main::cs + (byte) main::i#10) [86] (byte) printu::res#10 ← (byte) main::r#51 [87] call printu to:main::@55 @@ -2971,7 +2970,7 @@ main::@15: scope:[main] from main::@35 main::@58 [110] call printu to:main::@59 main::@59: scope:[main] from main::@15 - [111] if((byte) main::a#10<*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@16 + [111] if((byte) main::a#10<*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@16 to:main::@36 main::@36: scope:[main] from main::@59 [112] phi() @@ -2979,7 +2978,7 @@ main::@36: scope:[main] from main::@59 main::@16: scope:[main] from main::@36 main::@59 [113] (byte) main::r#55 ← phi( main::@36/(byte) '+' main::@59/(byte) '-' ) [114] (byte) printu::a#14 ← (byte) main::a#10 - [115] (byte) printu::b#14 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) + [115] (byte) printu::b#14 ← *((const byte[5]) main::cs + (byte) main::i#10) [116] (byte) printu::res#14 ← (byte) main::r#55 [117] call printu to:main::@60 @@ -3027,7 +3026,7 @@ main::@19: scope:[main] from main::@39 main::@63 [140] call printu to:main::@64 main::@64: scope:[main] from main::@19 - [141] if((byte) main::a#10!=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@20 + [141] if((byte) main::a#10!=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@20 to:main::@40 main::@40: scope:[main] from main::@64 [142] phi() @@ -3035,7 +3034,7 @@ main::@40: scope:[main] from main::@64 main::@20: scope:[main] from main::@40 main::@64 [143] (byte) main::r#59 ← phi( main::@40/(byte) '+' main::@64/(byte) '-' ) [144] (byte) printu::a#18 ← (byte) main::a#10 - [145] (byte) printu::b#18 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) + [145] (byte) printu::b#18 ← *((const byte[5]) main::cs + (byte) main::i#10) [146] (byte) printu::res#18 ← (byte) main::r#59 [147] call printu to:main::@65 @@ -3193,7 +3192,6 @@ VARIABLE REGISTER WEIGHTS (byte) main::a#10 3.860927152317884 (byte) main::b (byte) main::b#0 0.9758064516129035 -(byte[5]) main::cs (byte) main::i (byte) main::i#1 11.0 (byte) main::i#10 0.8684210526315792 @@ -3615,7 +3613,7 @@ main: { jmp b44 // main::@44 b44: - // [21] if((byte) main::a#10>=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@4 -- vbuz1_ge_pbuc1_derefidx_vbuz2_then_la1 + // [21] if((byte) main::a#10>=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@4 -- vbuz1_ge_pbuc1_derefidx_vbuz2_then_la1 lda.z a ldy.z i cmp cs,y @@ -3642,7 +3640,7 @@ main: { // [24] (byte) printu::a#2 ← (byte) main::a#10 -- vbuz1=vbuz2 lda.z a sta.z printu.a - // [25] (byte) printu::b#2 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 + // [25] (byte) printu::b#2 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 ldy.z i lda cs,y sta.z printu.b @@ -3823,7 +3821,7 @@ main: { jmp b49 // main::@49 b49: - // [51] if((byte) main::a#10<=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@8 -- vbuz1_le_pbuc1_derefidx_vbuz2_then_la1 + // [51] if((byte) main::a#10<=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@8 -- vbuz1_le_pbuc1_derefidx_vbuz2_then_la1 ldy.z i lda cs,y cmp.z a @@ -3850,7 +3848,7 @@ main: { // [54] (byte) printu::a#6 ← (byte) main::a#10 -- vbuz1=vbuz2 lda.z a sta.z printu.a - // [55] (byte) printu::b#6 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 + // [55] (byte) printu::b#6 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 ldy.z i lda cs,y sta.z printu.b @@ -4031,7 +4029,7 @@ main: { jmp b54 // main::@54 b54: - // [81] if((byte) main::a#10>*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@12 -- vbuz1_gt_pbuc1_derefidx_vbuz2_then_la1 + // [81] if((byte) main::a#10>*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@12 -- vbuz1_gt_pbuc1_derefidx_vbuz2_then_la1 ldy.z i lda cs,y cmp.z a @@ -4058,7 +4056,7 @@ main: { // [84] (byte) printu::a#10 ← (byte) main::a#10 -- vbuz1=vbuz2 lda.z a sta.z printu.a - // [85] (byte) printu::b#10 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 + // [85] (byte) printu::b#10 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 ldy.z i lda cs,y sta.z printu.b @@ -4239,7 +4237,7 @@ main: { jmp b59 // main::@59 b59: - // [111] if((byte) main::a#10<*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@16 -- vbuz1_lt_pbuc1_derefidx_vbuz2_then_la1 + // [111] if((byte) main::a#10<*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@16 -- vbuz1_lt_pbuc1_derefidx_vbuz2_then_la1 lda.z a ldy.z i cmp cs,y @@ -4266,7 +4264,7 @@ main: { // [114] (byte) printu::a#14 ← (byte) main::a#10 -- vbuz1=vbuz2 lda.z a sta.z printu.a - // [115] (byte) printu::b#14 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 + // [115] (byte) printu::b#14 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 ldy.z i lda cs,y sta.z printu.b @@ -4447,7 +4445,7 @@ main: { jmp b64 // main::@64 b64: - // [141] if((byte) main::a#10!=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@20 -- vbuz1_neq_pbuc1_derefidx_vbuz2_then_la1 + // [141] if((byte) main::a#10!=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@20 -- vbuz1_neq_pbuc1_derefidx_vbuz2_then_la1 lda.z a ldy.z i cmp cs,y @@ -4474,7 +4472,7 @@ main: { // [144] (byte) printu::a#18 ← (byte) main::a#10 -- vbuz1=vbuz2 lda.z a sta.z printu.a - // [145] (byte) printu::b#18 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 + // [145] (byte) printu::b#18 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 ldy.z i lda cs,y sta.z printu.b @@ -4888,23 +4886,23 @@ REGISTER UPLIFT POTENTIAL REGISTERS Statement [7] (byte) main::b#0 ← (byte) $ce - (byte) main::a#10 [ main::a#10 print_char_cursor#120 main::i#10 print_line_cursor#27 main::b#0 ] ( main:2 [ main::a#10 print_char_cursor#120 main::i#10 print_line_cursor#27 main::b#0 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp ZP_BYTE:2 [ main::a#10 main::a#1 ] Removing always clobbered register reg byte a as potential for zp ZP_BYTE:3 [ main::i#10 main::i#1 ] -Statement [21] if((byte) main::a#10>=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@4 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a +Statement [21] if((byte) main::a#10>=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@4 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp ZP_BYTE:39 [ main::b#0 ] Statement [28] if((byte) main::a#10>=(byte) main::a#10) goto main::@5 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [43] (byte*~) print_char_cursor#168 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#4 printu::b#4 printu::res#4 print_char_cursor#168 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#4 printu::b#4 printu::res#4 print_char_cursor#168 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp ZP_BYTE:26 [ printu::a#20 printu::a#8 printu::a#9 printu::a#10 printu::a#11 printu::a#12 printu::a#13 printu::a#14 printu::a#15 printu::a#16 printu::a#17 printu::a#0 printu::a#18 printu::a#19 printu::a#1 printu::a#2 printu::a#3 printu::a#4 printu::a#5 printu::a#6 printu::a#7 ] Removing always clobbered register reg byte a as potential for zp ZP_BYTE:29 [ printu::b#20 printu::b#8 printu::b#10 printu::b#11 printu::b#12 printu::b#14 printu::b#15 printu::b#16 printu::b#0 printu::b#18 printu::b#19 printu::b#2 printu::b#3 printu::b#4 printu::b#6 printu::b#7 ] Removing always clobbered register reg byte a as potential for zp ZP_BYTE:30 [ printu::res#20 printu::res#8 printu::res#9 printu::res#10 printu::res#11 printu::res#12 printu::res#13 printu::res#14 printu::res#15 printu::res#16 printu::res#17 printu::res#0 printu::res#18 printu::res#19 printu::res#1 printu::res#2 printu::res#3 printu::res#4 printu::res#5 printu::res#6 printu::res#7 ] -Statement [51] if((byte) main::a#10<=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@8 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a +Statement [51] if((byte) main::a#10<=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@8 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [58] if((byte) main::a#10<=(byte) main::a#10) goto main::@9 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [73] (byte*~) print_char_cursor#152 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#8 printu::b#8 printu::res#8 print_char_cursor#152 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#8 printu::b#8 printu::res#8 print_char_cursor#152 ] ) always clobbers reg byte a -Statement [81] if((byte) main::a#10>*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@12 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a +Statement [81] if((byte) main::a#10>*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@12 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [88] if((byte) main::a#10>(byte) main::a#10) goto main::@13 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [103] (byte*~) print_char_cursor#156 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#12 printu::b#12 printu::res#12 print_char_cursor#156 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#12 printu::b#12 printu::res#12 print_char_cursor#156 ] ) always clobbers reg byte a -Statement [111] if((byte) main::a#10<*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@16 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a +Statement [111] if((byte) main::a#10<*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@16 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [118] if((byte) main::a#10<(byte) main::a#10) goto main::@17 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [133] (byte*~) print_char_cursor#160 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 printu::a#16 printu::b#16 printu::res#16 print_char_cursor#160 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 printu::a#16 printu::b#16 printu::res#16 print_char_cursor#160 ] ) always clobbers reg byte a -Statement [141] if((byte) main::a#10!=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@20 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a +Statement [141] if((byte) main::a#10!=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@20 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a Statement [148] if((byte) main::a#10!=(byte) main::a#10) goto main::@21 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a Statement [157] (byte) main::a#1 ← (byte) main::a#10 + (byte) $30 [ main::i#10 main::a#1 print_line_cursor#1 ] ( main:2 [ main::i#10 main::a#1 print_line_cursor#1 ] ) always clobbers reg byte a Statement [161] (byte*~) print_char_cursor#151 ← (byte*) print_line_cursor#1 [ main::a#1 print_char_cursor#151 main::i#1 print_line_cursor#1 ] ( main:2 [ main::a#1 print_char_cursor#151 main::i#1 print_line_cursor#1 ] ) always clobbers reg byte a @@ -4927,19 +4925,19 @@ Statement [196] *((byte*) print_char_cursor#2) ← *((byte*) print_str::str#2) [ Statement [204] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:2::print_cls:5::memset:200 [ memset::dst#2 ] ) always clobbers reg byte a Statement [206] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:2::print_cls:5::memset:200 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y Statement [7] (byte) main::b#0 ← (byte) $ce - (byte) main::a#10 [ main::a#10 print_char_cursor#120 main::i#10 print_line_cursor#27 main::b#0 ] ( main:2 [ main::a#10 print_char_cursor#120 main::i#10 print_line_cursor#27 main::b#0 ] ) always clobbers reg byte a -Statement [21] if((byte) main::a#10>=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@4 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y +Statement [21] if((byte) main::a#10>=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@4 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y Statement [28] if((byte) main::a#10>=(byte) main::a#10) goto main::@5 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [43] (byte*~) print_char_cursor#168 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#4 printu::b#4 printu::res#4 print_char_cursor#168 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#4 printu::b#4 printu::res#4 print_char_cursor#168 ] ) always clobbers reg byte a -Statement [51] if((byte) main::a#10<=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@8 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a +Statement [51] if((byte) main::a#10<=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@8 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [58] if((byte) main::a#10<=(byte) main::a#10) goto main::@9 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [73] (byte*~) print_char_cursor#152 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#8 printu::b#8 printu::res#8 print_char_cursor#152 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#8 printu::b#8 printu::res#8 print_char_cursor#152 ] ) always clobbers reg byte a -Statement [81] if((byte) main::a#10>*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@12 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a +Statement [81] if((byte) main::a#10>*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@12 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [88] if((byte) main::a#10>(byte) main::a#10) goto main::@13 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [103] (byte*~) print_char_cursor#156 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#12 printu::b#12 printu::res#12 print_char_cursor#156 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#12 printu::b#12 printu::res#12 print_char_cursor#156 ] ) always clobbers reg byte a -Statement [111] if((byte) main::a#10<*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@16 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a +Statement [111] if((byte) main::a#10<*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@16 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [118] if((byte) main::a#10<(byte) main::a#10) goto main::@17 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [133] (byte*~) print_char_cursor#160 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 printu::a#16 printu::b#16 printu::res#16 print_char_cursor#160 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 printu::a#16 printu::b#16 printu::res#16 print_char_cursor#160 ] ) always clobbers reg byte a -Statement [141] if((byte) main::a#10!=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@20 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a +Statement [141] if((byte) main::a#10!=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@20 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a Statement [148] if((byte) main::a#10!=(byte) main::a#10) goto main::@21 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a Statement [157] (byte) main::a#1 ← (byte) main::a#10 + (byte) $30 [ main::i#10 main::a#1 print_line_cursor#1 ] ( main:2 [ main::i#10 main::a#1 print_line_cursor#1 ] ) always clobbers reg byte a reg byte x Removing always clobbered register reg byte x as potential for zp ZP_BYTE:3 [ main::i#10 main::i#1 ] @@ -4956,28 +4954,28 @@ Statement [196] *((byte*) print_char_cursor#2) ← *((byte*) print_str::str#2) [ Statement [204] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:2::print_cls:5::memset:200 [ memset::dst#2 ] ) always clobbers reg byte a Statement [206] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:2::print_cls:5::memset:200 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y Statement [7] (byte) main::b#0 ← (byte) $ce - (byte) main::a#10 [ main::a#10 print_char_cursor#120 main::i#10 print_line_cursor#27 main::b#0 ] ( main:2 [ main::a#10 print_char_cursor#120 main::i#10 print_line_cursor#27 main::b#0 ] ) always clobbers reg byte a -Statement [21] if((byte) main::a#10>=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@4 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y -Statement [25] (byte) printu::b#2 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 main::r#43 printu::a#2 printu::b#2 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 main::r#43 printu::a#2 printu::b#2 print_char_cursor#55 ] ) always clobbers reg byte y +Statement [21] if((byte) main::a#10>=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@4 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y +Statement [25] (byte) printu::b#2 ← *((const byte[5]) main::cs + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 main::r#43 printu::a#2 printu::b#2 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 main::r#43 printu::a#2 printu::b#2 print_char_cursor#55 ] ) always clobbers reg byte y Removing always clobbered register reg byte y as potential for zp ZP_BYTE:6 [ main::r#43 ] Statement [28] if((byte) main::a#10>=(byte) main::a#10) goto main::@5 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [43] (byte*~) print_char_cursor#168 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#4 printu::b#4 printu::res#4 print_char_cursor#168 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#4 printu::b#4 printu::res#4 print_char_cursor#168 ] ) always clobbers reg byte a -Statement [51] if((byte) main::a#10<=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@8 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y -Statement [55] (byte) printu::b#6 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#47 printu::a#6 printu::b#6 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#47 printu::a#6 printu::b#6 print_char_cursor#55 ] ) always clobbers reg byte y +Statement [51] if((byte) main::a#10<=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@8 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y +Statement [55] (byte) printu::b#6 ← *((const byte[5]) main::cs + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#47 printu::a#6 printu::b#6 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#47 printu::a#6 printu::b#6 print_char_cursor#55 ] ) always clobbers reg byte y Removing always clobbered register reg byte y as potential for zp ZP_BYTE:10 [ main::r#47 ] Statement [58] if((byte) main::a#10<=(byte) main::a#10) goto main::@9 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [73] (byte*~) print_char_cursor#152 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#8 printu::b#8 printu::res#8 print_char_cursor#152 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#8 printu::b#8 printu::res#8 print_char_cursor#152 ] ) always clobbers reg byte a -Statement [81] if((byte) main::a#10>*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@12 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y -Statement [85] (byte) printu::b#10 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#51 printu::a#10 printu::b#10 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#51 printu::a#10 printu::b#10 print_char_cursor#55 ] ) always clobbers reg byte y +Statement [81] if((byte) main::a#10>*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@12 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y +Statement [85] (byte) printu::b#10 ← *((const byte[5]) main::cs + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#51 printu::a#10 printu::b#10 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#51 printu::a#10 printu::b#10 print_char_cursor#55 ] ) always clobbers reg byte y Removing always clobbered register reg byte y as potential for zp ZP_BYTE:14 [ main::r#51 ] Statement [88] if((byte) main::a#10>(byte) main::a#10) goto main::@13 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [103] (byte*~) print_char_cursor#156 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#12 printu::b#12 printu::res#12 print_char_cursor#156 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#12 printu::b#12 printu::res#12 print_char_cursor#156 ] ) always clobbers reg byte a -Statement [111] if((byte) main::a#10<*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@16 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y -Statement [115] (byte) printu::b#14 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#55 printu::a#14 printu::b#14 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#55 printu::a#14 printu::b#14 print_char_cursor#55 ] ) always clobbers reg byte y +Statement [111] if((byte) main::a#10<*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@16 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y +Statement [115] (byte) printu::b#14 ← *((const byte[5]) main::cs + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#55 printu::a#14 printu::b#14 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#55 printu::a#14 printu::b#14 print_char_cursor#55 ] ) always clobbers reg byte y Removing always clobbered register reg byte y as potential for zp ZP_BYTE:18 [ main::r#55 ] Statement [118] if((byte) main::a#10<(byte) main::a#10) goto main::@17 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [133] (byte*~) print_char_cursor#160 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 printu::a#16 printu::b#16 printu::res#16 print_char_cursor#160 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 printu::a#16 printu::b#16 printu::res#16 print_char_cursor#160 ] ) always clobbers reg byte a -Statement [141] if((byte) main::a#10!=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@20 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y -Statement [145] (byte) printu::b#18 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::r#59 printu::a#18 printu::b#18 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::r#59 printu::a#18 printu::b#18 print_char_cursor#55 ] ) always clobbers reg byte y +Statement [141] if((byte) main::a#10!=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@20 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y +Statement [145] (byte) printu::b#18 ← *((const byte[5]) main::cs + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::r#59 printu::a#18 printu::b#18 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::r#59 printu::a#18 printu::b#18 print_char_cursor#55 ] ) always clobbers reg byte y Removing always clobbered register reg byte y as potential for zp ZP_BYTE:22 [ main::r#59 ] Statement [148] if((byte) main::a#10!=(byte) main::a#10) goto main::@21 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a Statement [157] (byte) main::a#1 ← (byte) main::a#10 + (byte) $30 [ main::i#10 main::a#1 print_line_cursor#1 ] ( main:2 [ main::i#10 main::a#1 print_line_cursor#1 ] ) always clobbers reg byte a reg byte x @@ -4994,24 +4992,24 @@ Statement [196] *((byte*) print_char_cursor#2) ← *((byte*) print_str::str#2) [ Statement [204] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:2::print_cls:5::memset:200 [ memset::dst#2 ] ) always clobbers reg byte a Statement [206] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:2::print_cls:5::memset:200 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y Statement [7] (byte) main::b#0 ← (byte) $ce - (byte) main::a#10 [ main::a#10 print_char_cursor#120 main::i#10 print_line_cursor#27 main::b#0 ] ( main:2 [ main::a#10 print_char_cursor#120 main::i#10 print_line_cursor#27 main::b#0 ] ) always clobbers reg byte a -Statement [21] if((byte) main::a#10>=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@4 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y -Statement [25] (byte) printu::b#2 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 main::r#43 printu::a#2 printu::b#2 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 main::r#43 printu::a#2 printu::b#2 print_char_cursor#55 ] ) always clobbers reg byte y +Statement [21] if((byte) main::a#10>=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@4 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y +Statement [25] (byte) printu::b#2 ← *((const byte[5]) main::cs + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 main::r#43 printu::a#2 printu::b#2 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 main::r#43 printu::a#2 printu::b#2 print_char_cursor#55 ] ) always clobbers reg byte y Statement [28] if((byte) main::a#10>=(byte) main::a#10) goto main::@5 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [43] (byte*~) print_char_cursor#168 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#4 printu::b#4 printu::res#4 print_char_cursor#168 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#4 printu::b#4 printu::res#4 print_char_cursor#168 ] ) always clobbers reg byte a -Statement [51] if((byte) main::a#10<=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@8 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y -Statement [55] (byte) printu::b#6 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#47 printu::a#6 printu::b#6 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#47 printu::a#6 printu::b#6 print_char_cursor#55 ] ) always clobbers reg byte y +Statement [51] if((byte) main::a#10<=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@8 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y +Statement [55] (byte) printu::b#6 ← *((const byte[5]) main::cs + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#47 printu::a#6 printu::b#6 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#47 printu::a#6 printu::b#6 print_char_cursor#55 ] ) always clobbers reg byte y Statement [58] if((byte) main::a#10<=(byte) main::a#10) goto main::@9 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [73] (byte*~) print_char_cursor#152 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#8 printu::b#8 printu::res#8 print_char_cursor#152 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#8 printu::b#8 printu::res#8 print_char_cursor#152 ] ) always clobbers reg byte a -Statement [81] if((byte) main::a#10>*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@12 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y -Statement [85] (byte) printu::b#10 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#51 printu::a#10 printu::b#10 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#51 printu::a#10 printu::b#10 print_char_cursor#55 ] ) always clobbers reg byte y +Statement [81] if((byte) main::a#10>*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@12 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y +Statement [85] (byte) printu::b#10 ← *((const byte[5]) main::cs + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#51 printu::a#10 printu::b#10 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#51 printu::a#10 printu::b#10 print_char_cursor#55 ] ) always clobbers reg byte y Statement [88] if((byte) main::a#10>(byte) main::a#10) goto main::@13 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [103] (byte*~) print_char_cursor#156 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#12 printu::b#12 printu::res#12 print_char_cursor#156 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#12 printu::b#12 printu::res#12 print_char_cursor#156 ] ) always clobbers reg byte a -Statement [111] if((byte) main::a#10<*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@16 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y -Statement [115] (byte) printu::b#14 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#55 printu::a#14 printu::b#14 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#55 printu::a#14 printu::b#14 print_char_cursor#55 ] ) always clobbers reg byte y +Statement [111] if((byte) main::a#10<*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@16 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y +Statement [115] (byte) printu::b#14 ← *((const byte[5]) main::cs + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#55 printu::a#14 printu::b#14 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#55 printu::a#14 printu::b#14 print_char_cursor#55 ] ) always clobbers reg byte y Statement [118] if((byte) main::a#10<(byte) main::a#10) goto main::@17 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a Statement [133] (byte*~) print_char_cursor#160 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 printu::a#16 printu::b#16 printu::res#16 print_char_cursor#160 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 printu::a#16 printu::b#16 printu::res#16 print_char_cursor#160 ] ) always clobbers reg byte a -Statement [141] if((byte) main::a#10!=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@20 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y -Statement [145] (byte) printu::b#18 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::r#59 printu::a#18 printu::b#18 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::r#59 printu::a#18 printu::b#18 print_char_cursor#55 ] ) always clobbers reg byte y +Statement [141] if((byte) main::a#10!=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@20 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y +Statement [145] (byte) printu::b#18 ← *((const byte[5]) main::cs + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::r#59 printu::a#18 printu::b#18 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::r#59 printu::a#18 printu::b#18 print_char_cursor#55 ] ) always clobbers reg byte y Statement [148] if((byte) main::a#10!=(byte) main::a#10) goto main::@21 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a Statement [157] (byte) main::a#1 ← (byte) main::a#10 + (byte) $30 [ main::i#10 main::a#1 print_line_cursor#1 ] ( main:2 [ main::i#10 main::a#1 print_line_cursor#1 ] ) always clobbers reg byte a reg byte x Statement [159] if((byte) main::i#1!=(byte) 5) goto main::@68 [ main::a#1 main::i#1 print_line_cursor#1 ] ( main:2 [ main::a#1 main::i#1 print_line_cursor#1 ] ) always clobbers reg byte a @@ -5291,7 +5289,7 @@ main: { jmp b44 // main::@44 b44: - // [21] if((byte) main::a#10>=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@4 -- vbuz1_ge_pbuc1_derefidx_vbuz2_then_la1 + // [21] if((byte) main::a#10>=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@4 -- vbuz1_ge_pbuc1_derefidx_vbuz2_then_la1 lda.z a ldy.z i cmp cs,y @@ -5314,7 +5312,7 @@ main: { // main::@4 b4: // [24] (byte) printu::a#2 ← (byte) main::a#10 - // [25] (byte) printu::b#2 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 + // [25] (byte) printu::b#2 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 ldy.z i lda cs,y sta.z printu.b @@ -5475,7 +5473,7 @@ main: { jmp b49 // main::@49 b49: - // [51] if((byte) main::a#10<=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@8 -- vbuz1_le_pbuc1_derefidx_vbuz2_then_la1 + // [51] if((byte) main::a#10<=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@8 -- vbuz1_le_pbuc1_derefidx_vbuz2_then_la1 ldy.z i lda cs,y cmp.z a @@ -5498,7 +5496,7 @@ main: { // main::@8 b8: // [54] (byte) printu::a#6 ← (byte) main::a#10 - // [55] (byte) printu::b#6 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 + // [55] (byte) printu::b#6 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 ldy.z i lda cs,y sta.z printu.b @@ -5659,7 +5657,7 @@ main: { jmp b54 // main::@54 b54: - // [81] if((byte) main::a#10>*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@12 -- vbuz1_gt_pbuc1_derefidx_vbuz2_then_la1 + // [81] if((byte) main::a#10>*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@12 -- vbuz1_gt_pbuc1_derefidx_vbuz2_then_la1 ldy.z i lda cs,y cmp.z a @@ -5682,7 +5680,7 @@ main: { // main::@12 b12: // [84] (byte) printu::a#10 ← (byte) main::a#10 - // [85] (byte) printu::b#10 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 + // [85] (byte) printu::b#10 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 ldy.z i lda cs,y sta.z printu.b @@ -5843,7 +5841,7 @@ main: { jmp b59 // main::@59 b59: - // [111] if((byte) main::a#10<*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@16 -- vbuz1_lt_pbuc1_derefidx_vbuz2_then_la1 + // [111] if((byte) main::a#10<*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@16 -- vbuz1_lt_pbuc1_derefidx_vbuz2_then_la1 lda.z a ldy.z i cmp cs,y @@ -5866,7 +5864,7 @@ main: { // main::@16 b16: // [114] (byte) printu::a#14 ← (byte) main::a#10 - // [115] (byte) printu::b#14 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 + // [115] (byte) printu::b#14 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 ldy.z i lda cs,y sta.z printu.b @@ -6027,7 +6025,7 @@ main: { jmp b64 // main::@64 b64: - // [141] if((byte) main::a#10!=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@20 -- vbuz1_neq_pbuc1_derefidx_vbuz2_then_la1 + // [141] if((byte) main::a#10!=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@20 -- vbuz1_neq_pbuc1_derefidx_vbuz2_then_la1 lda.z a ldy.z i cmp cs,y @@ -6050,7 +6048,7 @@ main: { // main::@20 b20: // [144] (byte) printu::a#18 ← (byte) main::a#10 - // [145] (byte) printu::b#18 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 + // [145] (byte) printu::b#18 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 ldy.z i lda cs,y sta.z printu.b @@ -6794,8 +6792,7 @@ FINAL SYMBOL TABLE (byte) main::a#10 a zp ZP_BYTE:2 3.860927152317884 (byte) main::b (byte) main::b#0 b zp ZP_BYTE:12 0.9758064516129035 -(byte[5]) main::cs -(const byte[5]) main::cs#0 cs = { (byte) 7, (byte) $c7, (byte) $37, (byte) $97, (byte) $67 } +(const byte[5]) main::cs cs = { (byte) 7, (byte) $c7, (byte) $37, (byte) $97, (byte) $67 } (byte) main::i (byte) main::i#1 i zp ZP_BYTE:3 11.0 (byte) main::i#10 i zp ZP_BYTE:3 0.8684210526315792 @@ -7119,7 +7116,7 @@ main: { jsr printu // main::@44 // if(a=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@4 -- vbuz1_ge_pbuc1_derefidx_vbuz2_then_la1 + // [21] if((byte) main::a#10>=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@4 -- vbuz1_ge_pbuc1_derefidx_vbuz2_then_la1 lda.z a ldy.z i cmp cs,y @@ -7138,7 +7135,7 @@ main: { b4: // printu(a, "< ", cs[i], r) // [24] (byte) printu::a#2 ← (byte) main::a#10 - // [25] (byte) printu::b#2 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 + // [25] (byte) printu::b#2 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 ldy.z i lda cs,y sta.z printu.b @@ -7277,7 +7274,7 @@ main: { jsr printu // main::@49 // if(a>cs[i]) - // [51] if((byte) main::a#10<=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@8 -- vbuz1_le_pbuc1_derefidx_vbuz2_then_la1 + // [51] if((byte) main::a#10<=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@8 -- vbuz1_le_pbuc1_derefidx_vbuz2_then_la1 ldy.z i lda cs,y cmp.z a @@ -7296,7 +7293,7 @@ main: { b8: // printu(a, "> ", cs[i], r) // [54] (byte) printu::a#6 ← (byte) main::a#10 - // [55] (byte) printu::b#6 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 + // [55] (byte) printu::b#6 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 ldy.z i lda cs,y sta.z printu.b @@ -7435,7 +7432,7 @@ main: { jsr printu // main::@54 // if(a<=cs[i]) - // [81] if((byte) main::a#10>*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@12 -- vbuz1_gt_pbuc1_derefidx_vbuz2_then_la1 + // [81] if((byte) main::a#10>*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@12 -- vbuz1_gt_pbuc1_derefidx_vbuz2_then_la1 ldy.z i lda cs,y cmp.z a @@ -7454,7 +7451,7 @@ main: { b12: // printu(a, "<=", cs[i], r) // [84] (byte) printu::a#10 ← (byte) main::a#10 - // [85] (byte) printu::b#10 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 + // [85] (byte) printu::b#10 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 ldy.z i lda cs,y sta.z printu.b @@ -7593,7 +7590,7 @@ main: { jsr printu // main::@59 // if(a>=cs[i]) - // [111] if((byte) main::a#10<*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@16 -- vbuz1_lt_pbuc1_derefidx_vbuz2_then_la1 + // [111] if((byte) main::a#10<*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@16 -- vbuz1_lt_pbuc1_derefidx_vbuz2_then_la1 lda.z a ldy.z i cmp cs,y @@ -7612,7 +7609,7 @@ main: { b16: // printu(a, ">=", cs[i], r) // [114] (byte) printu::a#14 ← (byte) main::a#10 - // [115] (byte) printu::b#14 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 + // [115] (byte) printu::b#14 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 ldy.z i lda cs,y sta.z printu.b @@ -7751,7 +7748,7 @@ main: { jsr printu // main::@64 // if(a==cs[i]) - // [141] if((byte) main::a#10!=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@20 -- vbuz1_neq_pbuc1_derefidx_vbuz2_then_la1 + // [141] if((byte) main::a#10!=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@20 -- vbuz1_neq_pbuc1_derefidx_vbuz2_then_la1 lda.z a ldy.z i cmp cs,y @@ -7770,7 +7767,7 @@ main: { b20: // printu(a, "==", cs[i], r) // [144] (byte) printu::a#18 ← (byte) main::a#10 - // [145] (byte) printu::b#18 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 + // [145] (byte) printu::b#18 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 ldy.z i lda cs,y sta.z printu.b diff --git a/src/test/ref/test-comparisons.sym b/src/test/ref/test-comparisons.sym index 0784b0b77..a5b40fd8c 100644 --- a/src/test/ref/test-comparisons.sym +++ b/src/test/ref/test-comparisons.sym @@ -79,8 +79,7 @@ (byte) main::a#10 a zp ZP_BYTE:2 3.860927152317884 (byte) main::b (byte) main::b#0 b zp ZP_BYTE:12 0.9758064516129035 -(byte[5]) main::cs -(const byte[5]) main::cs#0 cs = { (byte) 7, (byte) $c7, (byte) $37, (byte) $97, (byte) $67 } +(const byte[5]) main::cs cs = { (byte) 7, (byte) $c7, (byte) $37, (byte) $97, (byte) $67 } (byte) main::i (byte) main::i#1 i zp ZP_BYTE:3 11.0 (byte) main::i#10 i zp ZP_BYTE:3 0.8684210526315792