6502/kickc
1
0
Fork 0
mirror of https://gitlab.com/camelot/kickc.git synced 2024-09-09 08:54:40 +00:00
Code Issues Projects Releases Wiki Activity
239cfdb48e
kickc/src/test/ref/typeid-plus-bytes.log

2124 lines
112 KiB
Plaintext
Raw Blame History

Resolving typeid() (byte~) testUnsigned::$1 ← typeid (byte) testUnsigned::ubc1
Resolving typeid() (byte~) testUnsigned::$2 ← typeid (volatile byte) testUnsigned::ubv1
Resolving typeid() (byte~) testUnsigned::$13 ← typeid (byte~) testUnsigned::$12
Resolving typeid() (byte~) testUnsigned::$15 ← typeid (byte~) testUnsigned::$14
Resolving typeid() (byte~) testUnsigned::$17 ← typeid (byte~) testUnsigned::$16
Resolving typeid() (byte~) testSigned::$1 ← typeid (signed byte) testSigned::sbc1
Resolving typeid() (byte~) testSigned::$2 ← typeid (volatile signed byte) testSigned::sbv1
Resolving typeid() (byte~) testSigned::$13 ← typeid (signed byte~) testSigned::$12
Resolving typeid() (byte~) testSigned::$15 ← typeid (signed byte~) testSigned::$14
Resolving typeid() (byte~) testSigned::$17 ← typeid (signed byte~) testSigned::$16
CONTROL FLOW GRAPH SSA
@begin: scope:[] from
(byte) idx#0 ← (byte) 0
to:@1
(void()) main()
main: scope:[main] from @1
(byte) idx#1 ← (number) 0
call testUnsigned
to:main::@1
main::@1: scope:[main] from main
(byte) idx#59 ← phi( main/(byte) idx#21 )
(byte) idx#2 ← (byte) idx#59
(byte) idx#3 ← (number) $28
call testUnsignedVals
to:main::@2
main::@2: scope:[main] from main::@1
(byte) idx#60 ← phi( main::@1/(byte) idx#33 )
(byte) idx#4 ← (byte) idx#60
(byte) idx#5 ← (number) $28*(number) 2
call testSigned
to:main::@3
main::@3: scope:[main] from main::@2
(byte) idx#61 ← phi( main::@2/(byte) idx#45 )
(byte) idx#6 ← (byte) idx#61
(byte) idx#7 ← (number) $28*(number) 3
call testSignedVals
to:main::@4
main::@4: scope:[main] from main::@3
(byte) idx#62 ← phi( main::@3/(byte) idx#57 )
(byte) idx#8 ← (byte) idx#62
to:main::@return
main::@return: scope:[main] from main::@4
(byte) idx#63 ← phi( main::@4/(byte) idx#8 )
(byte) idx#9 ← (byte) idx#63
return
to:@return
(void()) testUnsigned()
testUnsigned: scope:[testUnsigned] from main
(byte) idx#64 ← phi( main/(byte) idx#1 )
(volatile byte) testUnsigned::ubv1 ← (byte) $fa
(byte~) testUnsigned::$0 ← typeid (number) $fa
*((const nomodify byte*) SCREEN + (byte) idx#64) ← (byte~) testUnsigned::$0
(byte) idx#10 ← ++ (byte) idx#64
(byte~) testUnsigned::$1 ← (const byte) TYPEID_BYTE
*((const nomodify byte*) SCREEN + (byte) idx#10) ← (byte~) testUnsigned::$1
(byte) idx#11 ← ++ (byte) idx#10
(byte~) testUnsigned::$2 ← (const byte) TYPEID_BYTE
*((const nomodify byte*) SCREEN + (byte) idx#11) ← (byte~) testUnsigned::$2
(byte) idx#12 ← ++ (byte) idx#11
(byte~) testUnsigned::$3 ← typeid (number) $78+(number) $82
*((const nomodify byte*) SCREEN + (byte) idx#12) ← (byte~) testUnsigned::$3
(byte) idx#13 ← ++ (byte) idx#12
(number~) testUnsigned::$4 ← (const byte) testUnsigned::ubc1 + (number) $fa
(byte~) testUnsigned::$5 ← typeid (number~) testUnsigned::$4
*((const nomodify byte*) SCREEN + (byte) idx#13) ← (byte~) testUnsigned::$5
(byte) idx#14 ← ++ (byte) idx#13
(number~) testUnsigned::$6 ← (number) $fa + (const byte) testUnsigned::ubc1
(byte~) testUnsigned::$7 ← typeid (number~) testUnsigned::$6
*((const nomodify byte*) SCREEN + (byte) idx#14) ← (byte~) testUnsigned::$7
(byte) idx#15 ← ++ (byte) idx#14
(number~) testUnsigned::$8 ← (volatile byte) testUnsigned::ubv1 + (number) $fa
(byte~) testUnsigned::$9 ← typeid (number~) testUnsigned::$8
*((const nomodify byte*) SCREEN + (byte) idx#15) ← (byte~) testUnsigned::$9
(byte) idx#16 ← ++ (byte) idx#15
(number~) testUnsigned::$10 ← (number) $fa + (volatile byte) testUnsigned::ubv1
(byte~) testUnsigned::$11 ← typeid (number~) testUnsigned::$10
*((const nomodify byte*) SCREEN + (byte) idx#16) ← (byte~) testUnsigned::$11
(byte) idx#17 ← ++ (byte) idx#16
(byte~) testUnsigned::$13 ← (const byte) TYPEID_BYTE
*((const nomodify byte*) SCREEN + (byte) idx#17) ← (byte~) testUnsigned::$13
(byte) idx#18 ← ++ (byte) idx#17
(byte~) testUnsigned::$15 ← (const byte) TYPEID_BYTE
*((const nomodify byte*) SCREEN + (byte) idx#18) ← (byte~) testUnsigned::$15
(byte) idx#19 ← ++ (byte) idx#18
(byte~) testUnsigned::$17 ← (const byte) TYPEID_BYTE
*((const nomodify byte*) SCREEN + (byte) idx#19) ← (byte~) testUnsigned::$17
(byte) idx#20 ← ++ (byte) idx#19
to:testUnsigned::@return
testUnsigned::@return: scope:[testUnsigned] from testUnsigned
(byte) idx#65 ← phi( testUnsigned/(byte) idx#20 )
(byte) idx#21 ← (byte) idx#65
return
to:@return
(void()) testUnsignedVals()
testUnsignedVals: scope:[testUnsignedVals] from main::@1
(byte) idx#66 ← phi( main::@1/(byte) idx#3 )
(volatile byte) testUnsignedVals::ubv1 ← (byte) $fa
*((const nomodify byte*) SCREEN + (byte) idx#66) ← (number) $fa
(byte) idx#22 ← ++ (byte) idx#66
*((const nomodify byte*) SCREEN + (byte) idx#22) ← (const byte) testUnsignedVals::ubc1
(byte) idx#23 ← ++ (byte) idx#22
*((const nomodify byte*) SCREEN + (byte) idx#23) ← (volatile byte) testUnsignedVals::ubv1
(byte) idx#24 ← ++ (byte) idx#23
*((const nomodify byte*) SCREEN + (byte) idx#24) ← (number) $78+(number) $82
(byte) idx#25 ← ++ (byte) idx#24
(number~) testUnsignedVals::$0 ← (const byte) testUnsignedVals::ubc1 + (number) $fa
*((const nomodify byte*) SCREEN + (byte) idx#25) ← (number~) testUnsignedVals::$0
(byte) idx#26 ← ++ (byte) idx#25
(number~) testUnsignedVals::$1 ← (number) $fa + (const byte) testUnsignedVals::ubc1
*((const nomodify byte*) SCREEN + (byte) idx#26) ← (number~) testUnsignedVals::$1
(byte) idx#27 ← ++ (byte) idx#26
(number~) testUnsignedVals::$2 ← (volatile byte) testUnsignedVals::ubv1 + (number) $fa
*((const nomodify byte*) SCREEN + (byte) idx#27) ← (number~) testUnsignedVals::$2
(byte) idx#28 ← ++ (byte) idx#27
(number~) testUnsignedVals::$3 ← (number) $fa + (volatile byte) testUnsignedVals::ubv1
*((const nomodify byte*) SCREEN + (byte) idx#28) ← (number~) testUnsignedVals::$3
(byte) idx#29 ← ++ (byte) idx#28
(byte~) testUnsignedVals::$4 ← (volatile byte) testUnsignedVals::ubv1 + (const byte) testUnsignedVals::ubc1
*((const nomodify byte*) SCREEN + (byte) idx#29) ← (byte~) testUnsignedVals::$4
(byte) idx#30 ← ++ (byte) idx#29
(byte~) testUnsignedVals::$5 ← (const byte) testUnsignedVals::ubc1 + (volatile byte) testUnsignedVals::ubv1
*((const nomodify byte*) SCREEN + (byte) idx#30) ← (byte~) testUnsignedVals::$5
(byte) idx#31 ← ++ (byte) idx#30
(byte~) testUnsignedVals::$6 ← (volatile byte) testUnsignedVals::ubv1 + (volatile byte) testUnsignedVals::ubv1
*((const nomodify byte*) SCREEN + (byte) idx#31) ← (byte~) testUnsignedVals::$6
(byte) idx#32 ← ++ (byte) idx#31
to:testUnsignedVals::@return
testUnsignedVals::@return: scope:[testUnsignedVals] from testUnsignedVals
(byte) idx#67 ← phi( testUnsignedVals/(byte) idx#32 )
(byte) idx#33 ← (byte) idx#67
return
to:@return
(void()) testSigned()
testSigned: scope:[testSigned] from main::@2
(byte) idx#68 ← phi( main::@2/(byte) idx#5 )
(volatile signed byte) testSigned::sbv1 ← (signed byte) -$78
(byte~) testSigned::$0 ← typeid (number) -$78
*((const nomodify byte*) SCREEN + (byte) idx#68) ← (byte~) testSigned::$0
(byte) idx#34 ← ++ (byte) idx#68
(byte~) testSigned::$1 ← (const byte) TYPEID_SIGNED_BYTE
*((const nomodify byte*) SCREEN + (byte) idx#34) ← (byte~) testSigned::$1
(byte) idx#35 ← ++ (byte) idx#34
(byte~) testSigned::$2 ← (const byte) TYPEID_SIGNED_BYTE
*((const nomodify byte*) SCREEN + (byte) idx#35) ← (byte~) testSigned::$2
(byte) idx#36 ← ++ (byte) idx#35
(byte~) testSigned::$3 ← typeid (number) -$78+(number) -$82
*((const nomodify byte*) SCREEN + (byte) idx#36) ← (byte~) testSigned::$3
(byte) idx#37 ← ++ (byte) idx#36
(number~) testSigned::$4 ← (const signed byte) testSigned::sbc1 + (number) -$78
(byte~) testSigned::$5 ← typeid (number~) testSigned::$4
*((const nomodify byte*) SCREEN + (byte) idx#37) ← (byte~) testSigned::$5
(byte) idx#38 ← ++ (byte) idx#37
(number~) testSigned::$6 ← (number) -$78 + (const signed byte) testSigned::sbc1
(byte~) testSigned::$7 ← typeid (number~) testSigned::$6
*((const nomodify byte*) SCREEN + (byte) idx#38) ← (byte~) testSigned::$7
(byte) idx#39 ← ++ (byte) idx#38
(number~) testSigned::$8 ← (volatile signed byte) testSigned::sbv1 + (number) -$78
(byte~) testSigned::$9 ← typeid (number~) testSigned::$8
*((const nomodify byte*) SCREEN + (byte) idx#39) ← (byte~) testSigned::$9
(byte) idx#40 ← ++ (byte) idx#39
(number~) testSigned::$10 ← (number) -$78 + (volatile signed byte) testSigned::sbv1
(byte~) testSigned::$11 ← typeid (number~) testSigned::$10
*((const nomodify byte*) SCREEN + (byte) idx#40) ← (byte~) testSigned::$11
(byte) idx#41 ← ++ (byte) idx#40
(byte~) testSigned::$13 ← (const byte) TYPEID_SIGNED_BYTE
*((const nomodify byte*) SCREEN + (byte) idx#41) ← (byte~) testSigned::$13
(byte) idx#42 ← ++ (byte) idx#41
(byte~) testSigned::$15 ← (const byte) TYPEID_SIGNED_BYTE
*((const nomodify byte*) SCREEN + (byte) idx#42) ← (byte~) testSigned::$15
(byte) idx#43 ← ++ (byte) idx#42
(byte~) testSigned::$17 ← (const byte) TYPEID_SIGNED_BYTE
*((const nomodify byte*) SCREEN + (byte) idx#43) ← (byte~) testSigned::$17
(byte) idx#44 ← ++ (byte) idx#43
to:testSigned::@return
testSigned::@return: scope:[testSigned] from testSigned
(byte) idx#69 ← phi( testSigned/(byte) idx#44 )
(byte) idx#45 ← (byte) idx#69
return
to:@return
(void()) testSignedVals()
testSignedVals: scope:[testSignedVals] from main::@3
(byte) idx#70 ← phi( main::@3/(byte) idx#7 )
(volatile signed byte) testSignedVals::sbv1 ← (signed byte) -$78
*((const nomodify signed byte*) SSCREEN + (byte) idx#70) ← (number) -$78
(byte) idx#46 ← ++ (byte) idx#70
*((const nomodify signed byte*) SSCREEN + (byte) idx#46) ← (const signed byte) testSignedVals::sbc1
(byte) idx#47 ← ++ (byte) idx#46
*((const nomodify signed byte*) SSCREEN + (byte) idx#47) ← (volatile signed byte) testSignedVals::sbv1
(byte) idx#48 ← ++ (byte) idx#47
*((const nomodify signed byte*) SSCREEN + (byte) idx#48) ← (number) -$46+(number) -$32
(byte) idx#49 ← ++ (byte) idx#48
(number~) testSignedVals::$0 ← (const signed byte) testSignedVals::sbc1 + (number) -$78
*((const nomodify signed byte*) SSCREEN + (byte) idx#49) ← (number~) testSignedVals::$0
(byte) idx#50 ← ++ (byte) idx#49
(number~) testSignedVals::$1 ← (number) -$78 + (const signed byte) testSignedVals::sbc1
*((const nomodify signed byte*) SSCREEN + (byte) idx#50) ← (number~) testSignedVals::$1
(byte) idx#51 ← ++ (byte) idx#50
(number~) testSignedVals::$2 ← (volatile signed byte) testSignedVals::sbv1 + (number) -$78
*((const nomodify signed byte*) SSCREEN + (byte) idx#51) ← (number~) testSignedVals::$2
(byte) idx#52 ← ++ (byte) idx#51
(number~) testSignedVals::$3 ← (number) -$78 + (volatile signed byte) testSignedVals::sbv1
*((const nomodify signed byte*) SSCREEN + (byte) idx#52) ← (number~) testSignedVals::$3
(byte) idx#53 ← ++ (byte) idx#52
(signed byte~) testSignedVals::$4 ← (volatile signed byte) testSignedVals::sbv1 + (const signed byte) testSignedVals::sbc1
*((const nomodify signed byte*) SSCREEN + (byte) idx#53) ← (signed byte~) testSignedVals::$4
(byte) idx#54 ← ++ (byte) idx#53
(signed byte~) testSignedVals::$5 ← (const signed byte) testSignedVals::sbc1 + (volatile signed byte) testSignedVals::sbv1
*((const nomodify signed byte*) SSCREEN + (byte) idx#54) ← (signed byte~) testSignedVals::$5
(byte) idx#55 ← ++ (byte) idx#54
(signed byte~) testSignedVals::$6 ← (volatile signed byte) testSignedVals::sbv1 + (volatile signed byte) testSignedVals::sbv1
*((const nomodify signed byte*) SSCREEN + (byte) idx#55) ← (signed byte~) testSignedVals::$6
(byte) idx#56 ← ++ (byte) idx#55
to:testSignedVals::@return
testSignedVals::@return: scope:[testSignedVals] from testSignedVals
(byte) idx#71 ← phi( testSignedVals/(byte) idx#56 )
(byte) idx#57 ← (byte) idx#71
return
to:@return
@1: scope:[] from @begin
(byte) idx#73 ← phi( @begin/(byte) idx#0 )
call main
to:@2
@2: scope:[] from @1
(byte) idx#72 ← phi( @1/(byte) idx#9 )
(byte) idx#58 ← (byte) idx#72
to:@end
@end: scope:[] from @2
SYMBOL TABLE SSA
(label) @1
(label) @2
(label) @begin
(label) @end
(const nomodify byte*) SCREEN = (byte*)(number) $400
(const nomodify signed byte*) SSCREEN = (signed byte*)(number) $400
(const byte) TYPEID_BYTE = (number) 1
(const byte) TYPEID_SIGNED_BYTE = (number) 2
(byte) idx
(byte) idx#0
(byte) idx#1
(byte) idx#10
(byte) idx#11
(byte) idx#12
(byte) idx#13
(byte) idx#14
(byte) idx#15
(byte) idx#16
(byte) idx#17
(byte) idx#18
(byte) idx#19
(byte) idx#2
(byte) idx#20
(byte) idx#21
(byte) idx#22
(byte) idx#23
(byte) idx#24
(byte) idx#25
(byte) idx#26
(byte) idx#27
(byte) idx#28
(byte) idx#29
(byte) idx#3
(byte) idx#30
(byte) idx#31
(byte) idx#32
(byte) idx#33
(byte) idx#34
(byte) idx#35
(byte) idx#36
(byte) idx#37
(byte) idx#38
(byte) idx#39
(byte) idx#4
(byte) idx#40
(byte) idx#41
(byte) idx#42
(byte) idx#43
(byte) idx#44
(byte) idx#45
(byte) idx#46
(byte) idx#47
(byte) idx#48
(byte) idx#49
(byte) idx#5
(byte) idx#50
(byte) idx#51
(byte) idx#52
(byte) idx#53
(byte) idx#54
(byte) idx#55
(byte) idx#56
(byte) idx#57
(byte) idx#58
(byte) idx#59
(byte) idx#6
(byte) idx#60
(byte) idx#61
(byte) idx#62
(byte) idx#63
(byte) idx#64
(byte) idx#65
(byte) idx#66
(byte) idx#67
(byte) idx#68
(byte) idx#69
(byte) idx#7
(byte) idx#70
(byte) idx#71
(byte) idx#72
(byte) idx#73
(byte) idx#8
(byte) idx#9
(void()) main()
(label) main::@1
(label) main::@2
(label) main::@3
(label) main::@4
(label) main::@return
(void()) testSigned()
(byte~) testSigned::$0
(byte~) testSigned::$1
(number~) testSigned::$10
(byte~) testSigned::$11
(byte~) testSigned::$13
(byte~) testSigned::$15
(byte~) testSigned::$17
(byte~) testSigned::$2
(byte~) testSigned::$3
(number~) testSigned::$4
(byte~) testSigned::$5
(number~) testSigned::$6
(byte~) testSigned::$7
(number~) testSigned::$8
(byte~) testSigned::$9
(label) testSigned::@return
(const signed byte) testSigned::sbc1 = (signed byte) -$78
(volatile signed byte) testSigned::sbv1 loadstore
(void()) testSignedVals()
(number~) testSignedVals::$0
(number~) testSignedVals::$1
(number~) testSignedVals::$2
(number~) testSignedVals::$3
(signed byte~) testSignedVals::$4
(signed byte~) testSignedVals::$5
(signed byte~) testSignedVals::$6
(label) testSignedVals::@return
(const signed byte) testSignedVals::sbc1 = (signed byte) -$78
(volatile signed byte) testSignedVals::sbv1 loadstore
(void()) testUnsigned()
(byte~) testUnsigned::$0
(byte~) testUnsigned::$1
(number~) testUnsigned::$10
(byte~) testUnsigned::$11
(byte~) testUnsigned::$13
(byte~) testUnsigned::$15
(byte~) testUnsigned::$17
(byte~) testUnsigned::$2
(byte~) testUnsigned::$3
(number~) testUnsigned::$4
(byte~) testUnsigned::$5
(number~) testUnsigned::$6
(byte~) testUnsigned::$7
(number~) testUnsigned::$8
(byte~) testUnsigned::$9
(label) testUnsigned::@return
(const byte) testUnsigned::ubc1 = (byte) $fa
(volatile byte) testUnsigned::ubv1 loadstore
(void()) testUnsignedVals()
(number~) testUnsignedVals::$0
(number~) testUnsignedVals::$1
(number~) testUnsignedVals::$2
(number~) testUnsignedVals::$3
(byte~) testUnsignedVals::$4
(byte~) testUnsignedVals::$5
(byte~) testUnsignedVals::$6
(label) testUnsignedVals::@return
(const byte) testUnsignedVals::ubc1 = (byte) $fa
(volatile byte) testUnsignedVals::ubv1 loadstore
Adding number conversion cast (unumber) 0 in (byte) idx#1 ← (number) 0
Adding number conversion cast (unumber) $28 in (byte) idx#3 ← (number) $28
Adding number conversion cast (unumber) $28*2 in (byte) idx#5 ← (number) $28*(number) 2
Adding number conversion cast (unumber) $28*3 in (byte) idx#7 ← (number) $28*(number) 3
Adding number conversion cast (unumber) $fa in (number~) testUnsigned::$4 ← (const byte) testUnsigned::ubc1 + (number) $fa
Adding number conversion cast (unumber) testUnsigned::$4 in (number~) testUnsigned::$4 ← (const byte) testUnsigned::ubc1 + (unumber)(number) $fa
Adding number conversion cast (unumber) $fa in (number~) testUnsigned::$6 ← (number) $fa + (const byte) testUnsigned::ubc1
Adding number conversion cast (unumber) testUnsigned::$6 in (number~) testUnsigned::$6 ← (unumber)(number) $fa + (const byte) testUnsigned::ubc1
Adding number conversion cast (unumber) $fa in (number~) testUnsigned::$8 ← (volatile byte) testUnsigned::ubv1 + (number) $fa
Adding number conversion cast (unumber) testUnsigned::$8 in (number~) testUnsigned::$8 ← (volatile byte) testUnsigned::ubv1 + (unumber)(number) $fa
Adding number conversion cast (unumber) $fa in (number~) testUnsigned::$10 ← (number) $fa + (volatile byte) testUnsigned::ubv1
Adding number conversion cast (unumber) testUnsigned::$10 in (number~) testUnsigned::$10 ← (unumber)(number) $fa + (volatile byte) testUnsigned::ubv1
Adding number conversion cast (unumber) $fa in *((const nomodify byte*) SCREEN + (byte) idx#66) ← (number) $fa
Adding number conversion cast (unumber) $78+$82 in *((const nomodify byte*) SCREEN + (byte) idx#24) ← (number) $78+(number) $82
Adding number conversion cast (unumber) $fa in (number~) testUnsignedVals::$0 ← (const byte) testUnsignedVals::ubc1 + (number) $fa
Adding number conversion cast (unumber) testUnsignedVals::$0 in (number~) testUnsignedVals::$0 ← (const byte) testUnsignedVals::ubc1 + (unumber)(number) $fa
Adding number conversion cast (unumber) $fa in (number~) testUnsignedVals::$1 ← (number) $fa + (const byte) testUnsignedVals::ubc1
Adding number conversion cast (unumber) testUnsignedVals::$1 in (number~) testUnsignedVals::$1 ← (unumber)(number) $fa + (const byte) testUnsignedVals::ubc1
Adding number conversion cast (unumber) $fa in (number~) testUnsignedVals::$2 ← (volatile byte) testUnsignedVals::ubv1 + (number) $fa
Adding number conversion cast (unumber) testUnsignedVals::$2 in (number~) testUnsignedVals::$2 ← (volatile byte) testUnsignedVals::ubv1 + (unumber)(number) $fa
Adding number conversion cast (unumber) $fa in (number~) testUnsignedVals::$3 ← (number) $fa + (volatile byte) testUnsignedVals::ubv1
Adding number conversion cast (unumber) testUnsignedVals::$3 in (number~) testUnsignedVals::$3 ← (unumber)(number) $fa + (volatile byte) testUnsignedVals::ubv1
Adding number conversion cast (snumber) -$78 in (number~) testSigned::$4 ← (const signed byte) testSigned::sbc1 + (number) -$78
Adding number conversion cast (snumber) testSigned::$4 in (number~) testSigned::$4 ← (const signed byte) testSigned::sbc1 + (snumber)(number) -$78
Adding number conversion cast (snumber) -$78 in (number~) testSigned::$6 ← (number) -$78 + (const signed byte) testSigned::sbc1
Adding number conversion cast (snumber) testSigned::$6 in (number~) testSigned::$6 ← (snumber)(number) -$78 + (const signed byte) testSigned::sbc1
Adding number conversion cast (snumber) -$78 in (number~) testSigned::$8 ← (volatile signed byte) testSigned::sbv1 + (number) -$78
Adding number conversion cast (snumber) testSigned::$8 in (number~) testSigned::$8 ← (volatile signed byte) testSigned::sbv1 + (snumber)(number) -$78
Adding number conversion cast (snumber) -$78 in (number~) testSigned::$10 ← (number) -$78 + (volatile signed byte) testSigned::sbv1
Adding number conversion cast (snumber) testSigned::$10 in (number~) testSigned::$10 ← (snumber)(number) -$78 + (volatile signed byte) testSigned::sbv1
Adding number conversion cast (snumber) -$78 in *((const nomodify signed byte*) SSCREEN + (byte) idx#70) ← (number) -$78
Adding number conversion cast (snumber) -$46+-$32 in *((const nomodify signed byte*) SSCREEN + (byte) idx#48) ← (number) -$46+(number) -$32
Adding number conversion cast (snumber) -$78 in (number~) testSignedVals::$0 ← (const signed byte) testSignedVals::sbc1 + (number) -$78
Adding number conversion cast (snumber) testSignedVals::$0 in (number~) testSignedVals::$0 ← (const signed byte) testSignedVals::sbc1 + (snumber)(number) -$78
Adding number conversion cast (snumber) -$78 in (number~) testSignedVals::$1 ← (number) -$78 + (const signed byte) testSignedVals::sbc1
Adding number conversion cast (snumber) testSignedVals::$1 in (number~) testSignedVals::$1 ← (snumber)(number) -$78 + (const signed byte) testSignedVals::sbc1
Adding number conversion cast (snumber) -$78 in (number~) testSignedVals::$2 ← (volatile signed byte) testSignedVals::sbv1 + (number) -$78
Adding number conversion cast (snumber) testSignedVals::$2 in (number~) testSignedVals::$2 ← (volatile signed byte) testSignedVals::sbv1 + (snumber)(number) -$78
Adding number conversion cast (snumber) -$78 in (number~) testSignedVals::$3 ← (number) -$78 + (volatile signed byte) testSignedVals::sbv1
Adding number conversion cast (snumber) testSignedVals::$3 in (number~) testSignedVals::$3 ← (snumber)(number) -$78 + (volatile signed byte) testSignedVals::sbv1
Successful SSA optimization PassNAddNumberTypeConversions
Inlining cast (byte) idx#1 ← (unumber)(number) 0
Inlining cast (byte) idx#3 ← (unumber)(number) $28
Inlining cast (byte) idx#5 ← (unumber)(number) $28*(number) 2
Inlining cast (byte) idx#7 ← (unumber)(number) $28*(number) 3
Inlining cast *((const nomodify byte*) SCREEN + (byte) idx#66) ← (unumber)(number) $fa
Inlining cast *((const nomodify byte*) SCREEN + (byte) idx#24) ← (unumber)(number) $78+(number) $82
Inlining cast *((const nomodify signed byte*) SSCREEN + (byte) idx#70) ← (snumber)(number) -$78
Inlining cast *((const nomodify signed byte*) SSCREEN + (byte) idx#48) ← (snumber)(number) -$46+(number) -$32
Successful SSA optimization Pass2InlineCast
Simplifying constant pointer cast (byte*) 1024
Simplifying constant pointer cast (signed byte*) 1024
Simplifying constant integer cast 0
Simplifying constant integer cast $28
Simplifying constant integer cast $fa
Simplifying constant integer cast $fa
Simplifying constant integer cast $fa
Simplifying constant integer cast $fa
Simplifying constant integer cast $fa
Simplifying constant integer cast $fa
Simplifying constant integer cast $fa
Simplifying constant integer cast $fa
Simplifying constant integer cast $fa
Simplifying constant integer cast -$78
Simplifying constant integer cast -$78
Simplifying constant integer cast -$78
Simplifying constant integer cast -$78
Simplifying constant integer cast -$78
Simplifying constant integer cast -$78
Simplifying constant integer cast -$78
Simplifying constant integer cast -$78
Simplifying constant integer cast -$78
Successful SSA optimization PassNCastSimplification
Finalized unsigned number type (byte) 0
Finalized unsigned number type (byte) $28
Finalized unsigned number type (byte) $fa
Finalized unsigned number type (byte) $fa
Finalized unsigned number type (byte) $fa
Finalized unsigned number type (byte) $fa
Finalized unsigned number type (byte) $fa
Finalized unsigned number type (byte) $fa
Finalized unsigned number type (byte) $fa
Finalized unsigned number type (byte) $fa
Finalized unsigned number type (byte) $fa
Finalized signed number type (signed byte) -$78
Finalized signed number type (signed byte) -$78
Finalized signed number type (signed byte) -$78
Finalized signed number type (signed byte) -$78
Finalized signed number type (signed byte) -$78
Finalized signed number type (signed byte) -$78
Finalized signed number type (signed byte) -$78
Finalized signed number type (signed byte) -$78
Finalized signed number type (signed byte) -$78
Successful SSA optimization PassNFinalizeNumberTypeConversions
Inferred type updated to byte in (unumber~) testUnsigned::$4 ← (const byte) testUnsigned::ubc1 + (byte) $fa
Inferred type updated to byte in (unumber~) testUnsigned::$6 ← (byte) $fa + (const byte) testUnsigned::ubc1
Inferred type updated to byte in (unumber~) testUnsigned::$8 ← (volatile byte) testUnsigned::ubv1 + (byte) $fa
Inferred type updated to byte in (unumber~) testUnsigned::$10 ← (byte) $fa + (volatile byte) testUnsigned::ubv1
Inferred type updated to byte in (unumber~) testUnsignedVals::$0 ← (const byte) testUnsignedVals::ubc1 + (byte) $fa
Inferred type updated to byte in (unumber~) testUnsignedVals::$1 ← (byte) $fa + (const byte) testUnsignedVals::ubc1
Inferred type updated to byte in (unumber~) testUnsignedVals::$2 ← (volatile byte) testUnsignedVals::ubv1 + (byte) $fa
Inferred type updated to byte in (unumber~) testUnsignedVals::$3 ← (byte) $fa + (volatile byte) testUnsignedVals::ubv1
Inferred type updated to signed byte in (snumber~) testSigned::$4 ← (const signed byte) testSigned::sbc1 + (signed byte) -$78
Inferred type updated to signed byte in (snumber~) testSigned::$6 ← (signed byte) -$78 + (const signed byte) testSigned::sbc1
Inferred type updated to signed byte in (snumber~) testSigned::$8 ← (volatile signed byte) testSigned::sbv1 + (signed byte) -$78
Inferred type updated to signed byte in (snumber~) testSigned::$10 ← (signed byte) -$78 + (volatile signed byte) testSigned::sbv1
Inferred type updated to signed byte in (snumber~) testSignedVals::$0 ← (const signed byte) testSignedVals::sbc1 + (signed byte) -$78
Inferred type updated to signed byte in (snumber~) testSignedVals::$1 ← (signed byte) -$78 + (const signed byte) testSignedVals::sbc1
Inferred type updated to signed byte in (snumber~) testSignedVals::$2 ← (volatile signed byte) testSignedVals::sbv1 + (signed byte) -$78
Inferred type updated to signed byte in (snumber~) testSignedVals::$3 ← (signed byte) -$78 + (volatile signed byte) testSignedVals::sbv1
Resolving typeid() (byte~) testUnsigned::$5 ← typeid (byte~) testUnsigned::$4
Resolving typeid() (byte~) testUnsigned::$7 ← typeid (byte~) testUnsigned::$6
Resolving typeid() (byte~) testUnsigned::$9 ← typeid (byte~) testUnsigned::$8
Resolving typeid() (byte~) testUnsigned::$11 ← typeid (byte~) testUnsigned::$10
Resolving typeid() (byte~) testSigned::$5 ← typeid (signed byte~) testSigned::$4
Resolving typeid() (byte~) testSigned::$7 ← typeid (signed byte~) testSigned::$6
Resolving typeid() (byte~) testSigned::$9 ← typeid (signed byte~) testSigned::$8
Resolving typeid() (byte~) testSigned::$11 ← typeid (signed byte~) testSigned::$10
Successful SSA optimization PassNTypeIdSimplification
Alias idx#2 = idx#59
Alias idx#4 = idx#60
Alias idx#6 = idx#61
Alias idx#62 = idx#8 idx#63 idx#9
Alias idx#20 = idx#65 idx#21
Alias idx#32 = idx#67 idx#33
Alias idx#44 = idx#69 idx#45
Alias idx#56 = idx#71 idx#57
Alias idx#0 = idx#73
Alias idx#58 = idx#72
Successful SSA optimization Pass2AliasElimination
Identical Phi Values (byte) idx#2 (byte) idx#20
Identical Phi Values (byte) idx#4 (byte) idx#32
Identical Phi Values (byte) idx#6 (byte) idx#44
Identical Phi Values (byte) idx#62 (byte) idx#56
Identical Phi Values (byte) idx#64 (byte) idx#1
Identical Phi Values (byte) idx#66 (byte) idx#3
Identical Phi Values (byte) idx#68 (byte) idx#5
Identical Phi Values (byte) idx#70 (byte) idx#7
Identical Phi Values (byte) idx#58 (byte) idx#62
Successful SSA optimization Pass2IdenticalPhiElimination
Constant right-side identified [7] (byte) idx#5 ← (unumber)(number) $28*(number) 2
Constant right-side identified [10] (byte) idx#7 ← (unumber)(number) $28*(number) 3
Constant right-side identified [16] (byte~) testUnsigned::$0 ← typeid (number) $fa
Constant right-side identified [25] (byte~) testUnsigned::$3 ← typeid (number) $78+(number) $82
Constant right-side identified [28] (byte~) testUnsigned::$4 ← (const byte) testUnsigned::ubc1 + (byte) $fa
Constant right-side identified [32] (byte~) testUnsigned::$6 ← (byte) $fa + (const byte) testUnsigned::ubc1
Constant right-side identified [62] *((const nomodify byte*) SCREEN + (byte) idx#24) ← (unumber)(number) $78+(number) $82
Constant right-side identified [64] (byte~) testUnsignedVals::$0 ← (const byte) testUnsignedVals::ubc1 + (byte) $fa
Constant right-side identified [67] (byte~) testUnsignedVals::$1 ← (byte) $fa + (const byte) testUnsignedVals::ubc1
Constant right-side identified [88] (byte~) testSigned::$0 ← typeid (number) -$78
Constant right-side identified [97] (byte~) testSigned::$3 ← typeid (number) -$78+(number) -$82
Constant right-side identified [100] (signed byte~) testSigned::$4 ← (const signed byte) testSigned::sbc1 + (signed byte) -$78
Constant right-side identified [104] (signed byte~) testSigned::$6 ← (signed byte) -$78 + (const signed byte) testSigned::sbc1
Constant right-side identified [134] *((const nomodify signed byte*) SSCREEN + (byte) idx#48) ← (snumber)(number) -$46+(number) -$32
Constant right-side identified [136] (signed byte~) testSignedVals::$0 ← (const signed byte) testSignedVals::sbc1 + (signed byte) -$78
Constant right-side identified [139] (signed byte~) testSignedVals::$1 ← (signed byte) -$78 + (const signed byte) testSignedVals::sbc1
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) idx#0 = 0
Constant (const byte) idx#1 = 0
Constant (const byte) idx#3 = $28
Constant (const byte) idx#5 = (unumber)$28*2
Constant (const byte) idx#7 = (unumber)$28*3
Constant (const byte) testUnsigned::$0 = typeid $fa
Constant (const byte) testUnsigned::$1 = TYPEID_BYTE
Constant (const byte) testUnsigned::$2 = TYPEID_BYTE
Constant (const byte) testUnsigned::$3 = typeid $78+$82
Constant (const byte) testUnsigned::$4 = testUnsigned::ubc1+$fa
Constant (const byte) testUnsigned::$5 = TYPEID_BYTE
Constant (const byte) testUnsigned::$6 = $fa+testUnsigned::ubc1
Constant (const byte) testUnsigned::$7 = TYPEID_BYTE
Constant (const byte) testUnsigned::$9 = TYPEID_BYTE
Constant (const byte) testUnsigned::$11 = TYPEID_BYTE
Constant (const byte) testUnsigned::$13 = TYPEID_BYTE
Constant (const byte) testUnsigned::$15 = TYPEID_BYTE
Constant (const byte) testUnsigned::$17 = TYPEID_BYTE
Constant (const byte) testUnsignedVals::$0 = testUnsignedVals::ubc1+$fa
Constant (const byte) testUnsignedVals::$1 = $fa+testUnsignedVals::ubc1
Constant (const byte) testSigned::$0 = typeid -$78
Constant (const byte) testSigned::$1 = TYPEID_SIGNED_BYTE
Constant (const byte) testSigned::$2 = TYPEID_SIGNED_BYTE
Constant (const byte) testSigned::$3 = typeid -$78+-$82
Constant (const signed byte) testSigned::$4 = testSigned::sbc1+-$78
Constant (const byte) testSigned::$5 = TYPEID_SIGNED_BYTE
Constant (const signed byte) testSigned::$6 = -$78+testSigned::sbc1
Constant (const byte) testSigned::$7 = TYPEID_SIGNED_BYTE
Constant (const byte) testSigned::$9 = TYPEID_SIGNED_BYTE
Constant (const byte) testSigned::$11 = TYPEID_SIGNED_BYTE
Constant (const byte) testSigned::$13 = TYPEID_SIGNED_BYTE
Constant (const byte) testSigned::$15 = TYPEID_SIGNED_BYTE
Constant (const byte) testSigned::$17 = TYPEID_SIGNED_BYTE
Constant (const signed byte) testSignedVals::$0 = testSignedVals::sbc1+-$78
Constant (const signed byte) testSignedVals::$1 = -$78+testSignedVals::sbc1
Successful SSA optimization Pass2ConstantIdentification
Simplifying constant evaluating to zero typeid (number) $fa in
Simplifying constant evaluating to zero typeid (number) $78+(number) $82 in
Simplifying constant evaluating to zero typeid (number) -$78 in
Simplifying constant evaluating to zero typeid (number) -$78+(number) -$82 in
Successful SSA optimization PassNSimplifyConstantZero
Simplifying expression containing zero SCREEN in [17] *((const nomodify byte*) SCREEN + (const byte) idx#1) ← (const byte) testUnsigned::$0
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused variable (byte~) testUnsigned::$8 and assignment [18] (byte~) testUnsigned::$8 ← (volatile byte) testUnsigned::ubv1 + (byte) $fa
Eliminating unused variable (byte~) testUnsigned::$10 and assignment [21] (byte~) testUnsigned::$10 ← (byte) $fa + (volatile byte) testUnsigned::ubv1
Eliminating unused variable (byte) idx#20 and assignment [29] (byte) idx#20 ← ++ (byte) idx#19
Eliminating unused variable (byte) idx#32 and assignment [58] (byte) idx#32 ← ++ (byte) idx#31
Eliminating unused variable (signed byte~) testSigned::$8 and assignment [73] (signed byte~) testSigned::$8 ← (volatile signed byte) testSigned::sbv1 + (signed byte) -$78
Eliminating unused variable (signed byte~) testSigned::$10 and assignment [76] (signed byte~) testSigned::$10 ← (signed byte) -$78 + (volatile signed byte) testSigned::sbv1
Eliminating unused variable (byte) idx#44 and assignment [84] (byte) idx#44 ← ++ (byte) idx#43
Eliminating unused variable (byte) idx#56 and assignment [113] (byte) idx#56 ← ++ (byte) idx#55
Eliminating unused constant (const byte) testUnsigned::$4
Eliminating unused constant (const byte) testUnsigned::$6
Eliminating unused constant (const signed byte) testSigned::$4
Eliminating unused constant (const signed byte) testSigned::$6
Eliminating unused constant (const byte) idx#0
Successful SSA optimization PassNEliminateUnusedVars
Eliminating unused variable (volatile byte) testUnsigned::ubv1 and assignment [5] (volatile byte) testUnsigned::ubv1 ← (byte) $fa
Eliminating unused variable (volatile signed byte) testSigned::sbv1 and assignment [56] (volatile signed byte) testSigned::sbv1 ← (signed byte) -$78
Eliminating unused constant (const byte) testUnsigned::ubc1
Eliminating unused constant (const signed byte) testSigned::sbc1
Successful SSA optimization PassNEliminateUnusedVars
Constant right-side identified [6] (byte) idx#10 ← ++ (const byte) idx#1
Constant right-side identified [29] (byte) idx#22 ← ++ (const byte) idx#3
Constant right-side identified [56] (byte) idx#34 ← ++ (const byte) idx#5
Constant right-side identified [79] (byte) idx#46 ← ++ (const byte) idx#7
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) idx#10 = ++idx#1
Constant (const byte) idx#22 = ++idx#3
Constant (const byte) idx#34 = ++idx#5
Constant (const byte) idx#46 = ++idx#7
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [7] (byte) idx#11 ← ++ (const byte) idx#10
Constant right-side identified [29] (byte) idx#23 ← ++ (const byte) idx#22
Constant right-side identified [55] (byte) idx#35 ← ++ (const byte) idx#34
Constant right-side identified [77] (byte) idx#47 ← ++ (const byte) idx#46
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) idx#11 = ++idx#10
Constant (const byte) idx#23 = ++idx#22
Constant (const byte) idx#35 = ++idx#34
Constant (const byte) idx#47 = ++idx#46
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [8] (byte) idx#12 ← ++ (const byte) idx#11
Constant right-side identified [29] (byte) idx#24 ← ++ (const byte) idx#23
Constant right-side identified [54] (byte) idx#36 ← ++ (const byte) idx#35
Constant right-side identified [75] (byte) idx#48 ← ++ (const byte) idx#47
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) idx#12 = ++idx#11
Constant (const byte) idx#24 = ++idx#23
Constant (const byte) idx#36 = ++idx#35
Constant (const byte) idx#48 = ++idx#47
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [9] (byte) idx#13 ← ++ (const byte) idx#12
Constant right-side identified [29] (byte) idx#25 ← ++ (const byte) idx#24
Constant right-side identified [53] (byte) idx#37 ← ++ (const byte) idx#36
Constant right-side identified [73] (byte) idx#49 ← ++ (const byte) idx#48
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) idx#13 = ++idx#12
Constant (const byte) idx#25 = ++idx#24
Constant (const byte) idx#37 = ++idx#36
Constant (const byte) idx#49 = ++idx#48
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [10] (byte) idx#14 ← ++ (const byte) idx#13
Constant right-side identified [29] (byte) idx#26 ← ++ (const byte) idx#25
Constant right-side identified [52] (byte) idx#38 ← ++ (const byte) idx#37
Constant right-side identified [71] (byte) idx#50 ← ++ (const byte) idx#49
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) idx#14 = ++idx#13
Constant (const byte) idx#26 = ++idx#25
Constant (const byte) idx#38 = ++idx#37
Constant (const byte) idx#50 = ++idx#49
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [11] (byte) idx#15 ← ++ (const byte) idx#14
Constant right-side identified [29] (byte) idx#27 ← ++ (const byte) idx#26
Constant right-side identified [51] (byte) idx#39 ← ++ (const byte) idx#38
Constant right-side identified [69] (byte) idx#51 ← ++ (const byte) idx#50
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) idx#15 = ++idx#14
Constant (const byte) idx#27 = ++idx#26
Constant (const byte) idx#39 = ++idx#38
Constant (const byte) idx#51 = ++idx#50
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [12] (byte) idx#16 ← ++ (const byte) idx#15
Constant right-side identified [30] (byte) idx#28 ← ++ (const byte) idx#27
Constant right-side identified [50] (byte) idx#40 ← ++ (const byte) idx#39
Constant right-side identified [68] (byte) idx#52 ← ++ (const byte) idx#51
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) idx#16 = ++idx#15
Constant (const byte) idx#28 = ++idx#27
Constant (const byte) idx#40 = ++idx#39
Constant (const byte) idx#52 = ++idx#51
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [13] (byte) idx#17 ← ++ (const byte) idx#16
Constant right-side identified [31] (byte) idx#29 ← ++ (const byte) idx#28
Constant right-side identified [49] (byte) idx#41 ← ++ (const byte) idx#40
Constant right-side identified [67] (byte) idx#53 ← ++ (const byte) idx#52
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) idx#17 = ++idx#16
Constant (const byte) idx#29 = ++idx#28
Constant (const byte) idx#41 = ++idx#40
Constant (const byte) idx#53 = ++idx#52
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [14] (byte) idx#18 ← ++ (const byte) idx#17
Constant right-side identified [32] (byte) idx#30 ← ++ (const byte) idx#29
Constant right-side identified [48] (byte) idx#42 ← ++ (const byte) idx#41
Constant right-side identified [66] (byte) idx#54 ← ++ (const byte) idx#53
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) idx#18 = ++idx#17
Constant (const byte) idx#30 = ++idx#29
Constant (const byte) idx#42 = ++idx#41
Constant (const byte) idx#54 = ++idx#53
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [15] (byte) idx#19 ← ++ (const byte) idx#18
Constant right-side identified [33] (byte) idx#31 ← ++ (const byte) idx#30
Constant right-side identified [47] (byte) idx#43 ← ++ (const byte) idx#42
Constant right-side identified [65] (byte) idx#55 ← ++ (const byte) idx#54
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) idx#19 = ++idx#18
Constant (const byte) idx#31 = ++idx#30
Constant (const byte) idx#43 = ++idx#42
Constant (const byte) idx#55 = ++idx#54
Successful SSA optimization Pass2ConstantIdentification
Inlining constant with different constant siblings (const byte) idx#1
Inlining constant with different constant siblings (const byte) idx#3
Inlining constant with different constant siblings (const byte) idx#5
Inlining constant with different constant siblings (const byte) idx#7
Inlining constant with different constant siblings (const byte) idx#10
Inlining constant with different constant siblings (const byte) idx#22
Inlining constant with different constant siblings (const byte) idx#34
Inlining constant with different constant siblings (const byte) idx#46
Inlining constant with different constant siblings (const byte) idx#11
Inlining constant with different constant siblings (const byte) idx#23
Inlining constant with different constant siblings (const byte) idx#35
Inlining constant with different constant siblings (const byte) idx#47
Inlining constant with different constant siblings (const byte) idx#12
Inlining constant with different constant siblings (const byte) idx#24
Inlining constant with different constant siblings (const byte) idx#36
Inlining constant with different constant siblings (const byte) idx#48
Inlining constant with different constant siblings (const byte) idx#13
Inlining constant with different constant siblings (const byte) idx#25
Inlining constant with different constant siblings (const byte) idx#37
Inlining constant with different constant siblings (const byte) idx#49
Inlining constant with different constant siblings (const byte) idx#14
Inlining constant with different constant siblings (const byte) idx#26
Inlining constant with different constant siblings (const byte) idx#38
Inlining constant with different constant siblings (const byte) idx#50
Inlining constant with different constant siblings (const byte) idx#15
Inlining constant with different constant siblings (const byte) idx#27
Inlining constant with different constant siblings (const byte) idx#39
Inlining constant with different constant siblings (const byte) idx#51
Inlining constant with different constant siblings (const byte) idx#16
Inlining constant with different constant siblings (const byte) idx#28
Inlining constant with different constant siblings (const byte) idx#40
Inlining constant with different constant siblings (const byte) idx#52
Inlining constant with different constant siblings (const byte) idx#17
Inlining constant with different constant siblings (const byte) idx#29
Inlining constant with different constant siblings (const byte) idx#41
Inlining constant with different constant siblings (const byte) idx#53
Inlining constant with different constant siblings (const byte) idx#18
Inlining constant with different constant siblings (const byte) idx#30
Inlining constant with different constant siblings (const byte) idx#42
Inlining constant with different constant siblings (const byte) idx#54
Inlining constant with different constant siblings (const byte) idx#19
Inlining constant with different constant siblings (const byte) idx#31
Inlining constant with different constant siblings (const byte) idx#43
Inlining constant with different constant siblings (const byte) idx#55
Constant inlined testUnsigned::$3 = (byte) 0
Constant inlined idx#31 = ++++++++++++++++++++(byte) $28
Constant inlined testUnsigned::$1 = (const byte) TYPEID_BYTE
Constant inlined idx#34 = ++(byte)(number) $28*(number) 2
Constant inlined testUnsigned::$2 = (const byte) TYPEID_BYTE
Constant inlined testUnsigned::$0 = (byte) 0
Constant inlined idx#30 = ++++++++++++++++++(byte) $28
Constant inlined idx#7 = (byte)(number) $28*(number) 3
Constant inlined idx#39 = ++++++++++++(byte)(number) $28*(number) 2
Constant inlined testUnsigned::$9 = (const byte) TYPEID_BYTE
Constant inlined testUnsigned::$7 = (const byte) TYPEID_BYTE
Constant inlined idx#36 = ++++++(byte)(number) $28*(number) 2
Constant inlined idx#35 = ++++(byte)(number) $28*(number) 2
Constant inlined testUnsigned::$5 = (const byte) TYPEID_BYTE
Constant inlined idx#38 = ++++++++++(byte)(number) $28*(number) 2
Constant inlined idx#37 = ++++++++(byte)(number) $28*(number) 2
Constant inlined testUnsigned::$17 = (const byte) TYPEID_BYTE
Constant inlined testUnsigned::$15 = (const byte) TYPEID_BYTE
Constant inlined idx#5 = (byte)(number) $28*(number) 2
Constant inlined idx#3 = (byte) $28
Constant inlined idx#1 = (byte) 0
Constant inlined idx#23 = ++++(byte) $28
Constant inlined idx#22 = ++(byte) $28
Constant inlined idx#29 = ++++++++++++++++(byte) $28
Constant inlined idx#28 = ++++++++++++++(byte) $28
Constant inlined idx#25 = ++++++++(byte) $28
Constant inlined idx#24 = ++++++(byte) $28
Constant inlined idx#27 = ++++++++++++(byte) $28
Constant inlined idx#26 = ++++++++++(byte) $28
Constant inlined testUnsignedVals::$0 = (const byte) testUnsignedVals::ubc1+(byte) $fa
Constant inlined testUnsignedVals::$1 = (byte) $fa+(const byte) testUnsignedVals::ubc1
Constant inlined idx#10 = ++(byte) 0
Constant inlined idx#54 = ++++++++++++++++++(byte)(number) $28*(number) 3
Constant inlined idx#53 = ++++++++++++++++(byte)(number) $28*(number) 3
Constant inlined idx#12 = ++++++(byte) 0
Constant inlined idx#11 = ++++(byte) 0
Constant inlined idx#55 = ++++++++++++++++++++(byte)(number) $28*(number) 3
Constant inlined idx#50 = ++++++++++(byte)(number) $28*(number) 3
Constant inlined idx#52 = ++++++++++++++(byte)(number) $28*(number) 3
Constant inlined idx#51 = ++++++++++++(byte)(number) $28*(number) 3
Constant inlined idx#18 = ++++++++++++++++++(byte) 0
Constant inlined idx#17 = ++++++++++++++++(byte) 0
Constant inlined idx#19 = ++++++++++++++++++++(byte) 0
Constant inlined idx#14 = ++++++++++(byte) 0
Constant inlined idx#13 = ++++++++(byte) 0
Constant inlined idx#16 = ++++++++++++++(byte) 0
Constant inlined idx#15 = ++++++++++++(byte) 0
Constant inlined testSigned::$7 = (const byte) TYPEID_SIGNED_BYTE
Constant inlined testSigned::$9 = (const byte) TYPEID_SIGNED_BYTE
Constant inlined testSigned::$2 = (const byte) TYPEID_SIGNED_BYTE
Constant inlined idx#43 = ++++++++++++++++++++(byte)(number) $28*(number) 2
Constant inlined testSigned::$17 = (const byte) TYPEID_SIGNED_BYTE
Constant inlined testSigned::$3 = (byte) 0
Constant inlined idx#42 = ++++++++++++++++++(byte)(number) $28*(number) 2
Constant inlined testSigned::$5 = (const byte) TYPEID_SIGNED_BYTE
Constant inlined testSigned::$13 = (const byte) TYPEID_SIGNED_BYTE
Constant inlined testSigned::$0 = (byte) 0
Constant inlined idx#41 = ++++++++++++++++(byte)(number) $28*(number) 2
Constant inlined testSigned::$1 = (const byte) TYPEID_SIGNED_BYTE
Constant inlined testSigned::$15 = (const byte) TYPEID_SIGNED_BYTE
Constant inlined idx#40 = ++++++++++++++(byte)(number) $28*(number) 2
Constant inlined testUnsigned::$13 = (const byte) TYPEID_BYTE
Constant inlined testUnsigned::$11 = (const byte) TYPEID_BYTE
Constant inlined testSignedVals::$1 = (signed byte) -$78+(const signed byte) testSignedVals::sbc1
Constant inlined testSigned::$11 = (const byte) TYPEID_SIGNED_BYTE
Constant inlined testSignedVals::$0 = (const signed byte) testSignedVals::sbc1+(signed byte) -$78
Constant inlined idx#47 = ++++(byte)(number) $28*(number) 3
Constant inlined idx#46 = ++(byte)(number) $28*(number) 3
Constant inlined idx#49 = ++++++++(byte)(number) $28*(number) 3
Constant inlined idx#48 = ++++++(byte)(number) $28*(number) 3
Successful SSA optimization Pass2ConstantInlining
Consolidated array index constant in *(SCREEN+++0)
Consolidated array index constant in *(SCREEN+++++0)
Consolidated array index constant in *(SCREEN+++++++0)
Consolidated array index constant in *(SCREEN+++++++++0)
Consolidated array index constant in *(SCREEN+++++++++++0)
Consolidated array index constant in *(SCREEN+++++++++++++0)
Consolidated array index constant in *(SCREEN+++++++++++++++0)
Consolidated array index constant in *(SCREEN+++++++++++++++++0)
Consolidated array index constant in *(SCREEN+++++++++++++++++++0)
Consolidated array index constant in *(SCREEN+++++++++++++++++++++0)
Consolidated array index constant in *(SCREEN+$28)
Consolidated array index constant in *(SCREEN+++$28)
Consolidated array index constant in *(SCREEN+++++$28)
Consolidated array index constant in *(SCREEN+++++++$28)
Consolidated array index constant in *(SCREEN+++++++++$28)
Consolidated array index constant in *(SCREEN+++++++++++$28)
Consolidated array index constant in *(SCREEN+++++++++++++$28)
Consolidated array index constant in *(SCREEN+++++++++++++++$28)
Consolidated array index constant in *(SCREEN+++++++++++++++++$28)
Consolidated array index constant in *(SCREEN+++++++++++++++++++$28)
Consolidated array index constant in *(SCREEN+++++++++++++++++++++$28)
Consolidated array index constant in *(SCREEN+(byte)$28*2)
Consolidated array index constant in *(SCREEN+++(byte)$28*2)
Consolidated array index constant in *(SCREEN+++++(byte)$28*2)
Consolidated array index constant in *(SCREEN+++++++(byte)$28*2)
Consolidated array index constant in *(SCREEN+++++++++(byte)$28*2)
Consolidated array index constant in *(SCREEN+++++++++++(byte)$28*2)
Consolidated array index constant in *(SCREEN+++++++++++++(byte)$28*2)
Consolidated array index constant in *(SCREEN+++++++++++++++(byte)$28*2)
Consolidated array index constant in *(SCREEN+++++++++++++++++(byte)$28*2)
Consolidated array index constant in *(SCREEN+++++++++++++++++++(byte)$28*2)
Consolidated array index constant in *(SCREEN+++++++++++++++++++++(byte)$28*2)
Consolidated array index constant in *(SSCREEN+(byte)$28*3)
Consolidated array index constant in *(SSCREEN+++(byte)$28*3)
Consolidated array index constant in *(SSCREEN+++++(byte)$28*3)
Consolidated array index constant in *(SSCREEN+++++++(byte)$28*3)
Consolidated array index constant in *(SSCREEN+++++++++(byte)$28*3)
Consolidated array index constant in *(SSCREEN+++++++++++(byte)$28*3)
Consolidated array index constant in *(SSCREEN+++++++++++++(byte)$28*3)
Consolidated array index constant in *(SSCREEN+++++++++++++++(byte)$28*3)
Consolidated array index constant in *(SSCREEN+++++++++++++++++(byte)$28*3)
Consolidated array index constant in *(SSCREEN+++++++++++++++++++(byte)$28*3)
Consolidated array index constant in *(SSCREEN+++++++++++++++++++++(byte)$28*3)
Successful SSA optimization Pass2ConstantAdditionElimination
Simplifying constant integer increment ++0
Simplifying constant integer increment ++0
Simplifying constant integer increment ++1
Simplifying constant integer increment ++2
Simplifying constant integer increment ++3
Simplifying constant integer increment ++4
Simplifying constant integer increment ++5
Simplifying constant integer increment ++6
Simplifying constant integer increment ++7
Simplifying constant integer increment ++8
Simplifying constant integer increment ++$28
Simplifying constant integer increment ++$28
Simplifying constant integer increment ++$29
Simplifying constant integer increment ++$2a
Simplifying constant integer increment ++$2b
Simplifying constant integer increment ++$2c
Simplifying constant integer increment ++$2d
Simplifying constant integer increment ++$2e
Simplifying constant integer increment ++$2f
Simplifying constant integer increment ++$30
Successful SSA optimization Pass2ConstantSimplification
Simplifying constant integer increment ++1
Simplifying constant integer increment ++2
Simplifying constant integer increment ++3
Simplifying constant integer increment ++4
Simplifying constant integer increment ++5
Simplifying constant integer increment ++6
Simplifying constant integer increment ++7
Simplifying constant integer increment ++8
Simplifying constant integer increment ++9
Simplifying constant integer increment ++$29
Simplifying constant integer increment ++$2a
Simplifying constant integer increment ++$2b
Simplifying constant integer increment ++$2c
Simplifying constant integer increment ++$2d
Simplifying constant integer increment ++$2e
Simplifying constant integer increment ++$2f
Simplifying constant integer increment ++$30
Simplifying constant integer increment ++$31
Successful SSA optimization Pass2ConstantSimplification
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @1
Adding NOP phi() at start of @2
Adding NOP phi() at start of @end
Adding NOP phi() at start of main
Adding NOP phi() at start of main::@1
Adding NOP phi() at start of main::@2
Adding NOP phi() at start of main::@3
Adding NOP phi() at start of main::@4
CALL GRAPH
Calls in [] to main:2
Calls in [main] to testUnsigned:6 testUnsignedVals:8 testSigned:10 testSignedVals:12
Created 0 initial phi equivalence classes
Coalesced down to 0 phi equivalence classes
Culled Empty Block (label) @2
Culled Empty Block (label) main::@4
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @1
Adding NOP phi() at start of @end
Adding NOP phi() at start of main
Adding NOP phi() at start of main::@1
Adding NOP phi() at start of main::@2
Adding NOP phi() at start of main::@3
FINAL CONTROL FLOW GRAPH
@begin: scope:[] from
[0] phi()
to:@1
@1: scope:[] from @begin
[1] phi()
[2] call main
to:@end
@end: scope:[] from @1
[3] phi()
(void()) main()
main: scope:[main] from @1
[4] phi()
[5] call testUnsigned
to:main::@1
main::@1: scope:[main] from main
[6] phi()
[7] call testUnsignedVals
to:main::@2
main::@2: scope:[main] from main::@1
[8] phi()
[9] call testSigned
to:main::@3
main::@3: scope:[main] from main::@2
[10] phi()
[11] call testSignedVals
to:main::@return
main::@return: scope:[main] from main::@3
[12] return
to:@return
(void()) testSignedVals()
testSignedVals: scope:[testSignedVals] from main::@3
[13] (volatile signed byte) testSignedVals::sbv1 ← (signed byte) -$78
[14] *((const nomodify signed byte*) SSCREEN+(byte)(number) $28*(number) 3) ← (signed byte) -$78
[15] *((const nomodify signed byte*) SSCREEN+++(byte)(number) $28*(number) 3) ← (const signed byte) testSignedVals::sbc1
[16] *((const nomodify signed byte*) SSCREEN+++++(byte)(number) $28*(number) 3) ← (volatile signed byte) testSignedVals::sbv1
[17] *((const nomodify signed byte*) SSCREEN+++++++(byte)(number) $28*(number) 3) ← (signed byte)(number) -$46+(number) -$32
[18] *((const nomodify signed byte*) SSCREEN+++++++++(byte)(number) $28*(number) 3) ← (const signed byte) testSignedVals::sbc1+(signed byte) -$78
[19] *((const nomodify signed byte*) SSCREEN+++++++++++(byte)(number) $28*(number) 3) ← (signed byte) -$78+(const signed byte) testSignedVals::sbc1
[20] (signed byte~) testSignedVals::$2 ← (volatile signed byte) testSignedVals::sbv1 + (signed byte) -$78
[21] *((const nomodify signed byte*) SSCREEN+++++++++++++(byte)(number) $28*(number) 3) ← (signed byte~) testSignedVals::$2
[22] (signed byte~) testSignedVals::$3 ← (signed byte) -$78 + (volatile signed byte) testSignedVals::sbv1
[23] *((const nomodify signed byte*) SSCREEN+++++++++++++++(byte)(number) $28*(number) 3) ← (signed byte~) testSignedVals::$3
[24] (signed byte~) testSignedVals::$4 ← (volatile signed byte) testSignedVals::sbv1 + (const signed byte) testSignedVals::sbc1
[25] *((const nomodify signed byte*) SSCREEN+++++++++++++++++(byte)(number) $28*(number) 3) ← (signed byte~) testSignedVals::$4
[26] (signed byte~) testSignedVals::$5 ← (const signed byte) testSignedVals::sbc1 + (volatile signed byte) testSignedVals::sbv1
[27] *((const nomodify signed byte*) SSCREEN+++++++++++++++++++(byte)(number) $28*(number) 3) ← (signed byte~) testSignedVals::$5
[28] (signed byte~) testSignedVals::$6 ← (volatile signed byte) testSignedVals::sbv1 + (volatile signed byte) testSignedVals::sbv1
[29] *((const nomodify signed byte*) SSCREEN+++++++++++++++++++++(byte)(number) $28*(number) 3) ← (signed byte~) testSignedVals::$6
to:testSignedVals::@return
testSignedVals::@return: scope:[testSignedVals] from testSignedVals
[30] return
to:@return
(void()) testSigned()
testSigned: scope:[testSigned] from main::@2
[31] *((const nomodify byte*) SCREEN+(byte)(number) $28*(number) 2) ← (byte) 0
[32] *((const nomodify byte*) SCREEN+++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE
[33] *((const nomodify byte*) SCREEN+++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE
[34] *((const nomodify byte*) SCREEN+++++++(byte)(number) $28*(number) 2) ← (byte) 0
[35] *((const nomodify byte*) SCREEN+++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE
[36] *((const nomodify byte*) SCREEN+++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE
[37] *((const nomodify byte*) SCREEN+++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE
[38] *((const nomodify byte*) SCREEN+++++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE
[39] *((const nomodify byte*) SCREEN+++++++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE
[40] *((const nomodify byte*) SCREEN+++++++++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE
[41] *((const nomodify byte*) SCREEN+++++++++++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE
to:testSigned::@return
testSigned::@return: scope:[testSigned] from testSigned
[42] return
to:@return
(void()) testUnsignedVals()
testUnsignedVals: scope:[testUnsignedVals] from main::@1
[43] (volatile byte) testUnsignedVals::ubv1 ← (byte) $fa
[44] *((const nomodify byte*) SCREEN+(byte) $28) ← (byte) $fa
[45] *((const nomodify byte*) SCREEN+(byte) $29) ← (const byte) testUnsignedVals::ubc1
[46] *((const nomodify byte*) SCREEN+(byte) $2a) ← (volatile byte) testUnsignedVals::ubv1
[47] *((const nomodify byte*) SCREEN+(byte) $2b) ← (byte)(number) $78+(number) $82
[48] *((const nomodify byte*) SCREEN+(byte) $2c) ← (const byte) testUnsignedVals::ubc1+(byte) $fa
[49] *((const nomodify byte*) SCREEN+(byte) $2d) ← (byte) $fa+(const byte) testUnsignedVals::ubc1
[50] (byte~) testUnsignedVals::$2 ← (volatile byte) testUnsignedVals::ubv1 + (byte) $fa
[51] *((const nomodify byte*) SCREEN+(byte) $2e) ← (byte~) testUnsignedVals::$2
[52] (byte~) testUnsignedVals::$3 ← (byte) $fa + (volatile byte) testUnsignedVals::ubv1
[53] *((const nomodify byte*) SCREEN+(byte) $2f) ← (byte~) testUnsignedVals::$3
[54] (byte~) testUnsignedVals::$4 ← (volatile byte) testUnsignedVals::ubv1 + (const byte) testUnsignedVals::ubc1
[55] *((const nomodify byte*) SCREEN+(byte) $30) ← (byte~) testUnsignedVals::$4
[56] (byte~) testUnsignedVals::$5 ← (const byte) testUnsignedVals::ubc1 + (volatile byte) testUnsignedVals::ubv1
[57] *((const nomodify byte*) SCREEN+(byte) $31) ← (byte~) testUnsignedVals::$5
[58] (byte~) testUnsignedVals::$6 ← (volatile byte) testUnsignedVals::ubv1 + (volatile byte) testUnsignedVals::ubv1
[59] *((const nomodify byte*) SCREEN+(byte) $32) ← (byte~) testUnsignedVals::$6
to:testUnsignedVals::@return
testUnsignedVals::@return: scope:[testUnsignedVals] from testUnsignedVals
[60] return
to:@return
(void()) testUnsigned()
testUnsigned: scope:[testUnsigned] from main
[61] *((const nomodify byte*) SCREEN) ← (byte) 0
[62] *((const nomodify byte*) SCREEN+(byte) 1) ← (const byte) TYPEID_BYTE
[63] *((const nomodify byte*) SCREEN+(byte) 2) ← (const byte) TYPEID_BYTE
[64] *((const nomodify byte*) SCREEN+(byte) 3) ← (byte) 0
[65] *((const nomodify byte*) SCREEN+(byte) 4) ← (const byte) TYPEID_BYTE
[66] *((const nomodify byte*) SCREEN+(byte) 5) ← (const byte) TYPEID_BYTE
[67] *((const nomodify byte*) SCREEN+(byte) 6) ← (const byte) TYPEID_BYTE
[68] *((const nomodify byte*) SCREEN+(byte) 7) ← (const byte) TYPEID_BYTE
[69] *((const nomodify byte*) SCREEN+(byte) 8) ← (const byte) TYPEID_BYTE
[70] *((const nomodify byte*) SCREEN+(byte) 9) ← (const byte) TYPEID_BYTE
[71] *((const nomodify byte*) SCREEN+(byte) $a) ← (const byte) TYPEID_BYTE
to:testUnsigned::@return
testUnsigned::@return: scope:[testUnsigned] from testUnsigned
[72] return
to:@return
VARIABLE REGISTER WEIGHTS
(byte) idx
(void()) main()
(void()) testSigned()
(void()) testSignedVals()
(signed byte~) testSignedVals::$2 202.0
(signed byte~) testSignedVals::$3 202.0
(signed byte~) testSignedVals::$4 202.0
(signed byte~) testSignedVals::$5 202.0
(signed byte~) testSignedVals::$6 202.0
(volatile signed byte) testSignedVals::sbv1 loadstore 53.86666666666667
(void()) testUnsigned()
(void()) testUnsignedVals()
(byte~) testUnsignedVals::$2 202.0
(byte~) testUnsignedVals::$3 202.0
(byte~) testUnsignedVals::$4 202.0
(byte~) testUnsignedVals::$5 202.0
(byte~) testUnsignedVals::$6 202.0
(volatile byte) testUnsignedVals::ubv1 loadstore 53.86666666666667
Initial phi equivalence classes
Added variable testSignedVals::sbv1 to live range equivalence class [ testSignedVals::sbv1 ]
Added variable testSignedVals::$2 to live range equivalence class [ testSignedVals::$2 ]
Added variable testSignedVals::$3 to live range equivalence class [ testSignedVals::$3 ]
Added variable testSignedVals::$4 to live range equivalence class [ testSignedVals::$4 ]
Added variable testSignedVals::$5 to live range equivalence class [ testSignedVals::$5 ]
Added variable testSignedVals::$6 to live range equivalence class [ testSignedVals::$6 ]
Added variable testUnsignedVals::ubv1 to live range equivalence class [ testUnsignedVals::ubv1 ]
Added variable testUnsignedVals::$2 to live range equivalence class [ testUnsignedVals::$2 ]
Added variable testUnsignedVals::$3 to live range equivalence class [ testUnsignedVals::$3 ]
Added variable testUnsignedVals::$4 to live range equivalence class [ testUnsignedVals::$4 ]
Added variable testUnsignedVals::$5 to live range equivalence class [ testUnsignedVals::$5 ]
Added variable testUnsignedVals::$6 to live range equivalence class [ testUnsignedVals::$6 ]
Complete equivalence classes
[ testSignedVals::sbv1 ]
[ testSignedVals::$2 ]
[ testSignedVals::$3 ]
[ testSignedVals::$4 ]
[ testSignedVals::$5 ]
[ testSignedVals::$6 ]
[ testUnsignedVals::ubv1 ]
[ testUnsignedVals::$2 ]
[ testUnsignedVals::$3 ]
[ testUnsignedVals::$4 ]
[ testUnsignedVals::$5 ]
[ testUnsignedVals::$6 ]
Allocated zp[1]:2 [ testSignedVals::sbv1 ]
Allocated zp[1]:3 [ testSignedVals::$2 ]
Allocated zp[1]:4 [ testSignedVals::$3 ]
Allocated zp[1]:5 [ testSignedVals::$4 ]
Allocated zp[1]:6 [ testSignedVals::$5 ]
Allocated zp[1]:7 [ testSignedVals::$6 ]
Allocated zp[1]:8 [ testUnsignedVals::ubv1 ]
Allocated zp[1]:9 [ testUnsignedVals::$2 ]
Allocated zp[1]:10 [ testUnsignedVals::$3 ]
Allocated zp[1]:11 [ testUnsignedVals::$4 ]
Allocated zp[1]:12 [ testUnsignedVals::$5 ]
Allocated zp[1]:13 [ testUnsignedVals::$6 ]
INITIAL ASM
Target platform is c64basic / MOS6502X
// File Comments
// Test that plus creates the expected type for all legal combinations of bytes (signed/unsigned - constant/variable)
// Upstart
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
// Global Constants & labels
.const TYPEID_BYTE = 1
.const TYPEID_SIGNED_BYTE = 2
.label SCREEN = $400
.label SSCREEN = $400
// @begin
__bbegin:
// [1] phi from @begin to @1 [phi:@begin->@1]
__b1_from___bbegin:
jmp __b1
// @1
__b1:
// [2] call main
// [4] phi from @1 to main [phi:@1->main]
main_from___b1:
jsr main
// [3] phi from @1 to @end [phi:@1->@end]
__bend_from___b1:
jmp __bend
// @end
__bend:
// main
main: {
// [5] call testUnsigned
jsr testUnsigned
// [6] phi from main to main::@1 [phi:main->main::@1]
__b1_from_main:
jmp __b1
// main::@1
__b1:
// [7] call testUnsignedVals
jsr testUnsignedVals
// [8] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
__b2_from___b1:
jmp __b2
// main::@2
__b2:
// [9] call testSigned
jsr testSigned
// [10] phi from main::@2 to main::@3 [phi:main::@2->main::@3]
__b3_from___b2:
jmp __b3
// main::@3
__b3:
// [11] call testSignedVals
jsr testSignedVals
jmp __breturn
// main::@return
__breturn:
// [12] return
rts
}
// testSignedVals
testSignedVals: {
.const sbc1 = -$78
.label sbv1 = 2
.label __2 = 3
.label __3 = 4
.label __4 = 5
.label __5 = 6
.label __6 = 7
// [13] (volatile signed byte) testSignedVals::sbv1 ← (signed byte) -$78 -- vbsz1=vbsc1
lda #-$78
sta.z sbv1
// [14] *((const nomodify signed byte*) SSCREEN+(byte)(number) $28*(number) 3) ← (signed byte) -$78 -- _deref_pbsc1=vbsc2
lda #-$78
sta SSCREEN+$28*3
// [15] *((const nomodify signed byte*) SSCREEN+++(byte)(number) $28*(number) 3) ← (const signed byte) testSignedVals::sbc1 -- _deref_pbsc1=vbsc2
lda #sbc1
sta SSCREEN+$28*3+1
// [16] *((const nomodify signed byte*) SSCREEN+++++(byte)(number) $28*(number) 3) ← (volatile signed byte) testSignedVals::sbv1 -- _deref_pbsc1=vbsz1
lda.z sbv1
sta SSCREEN+$28*3+1+1
// [17] *((const nomodify signed byte*) SSCREEN+++++++(byte)(number) $28*(number) 3) ← (signed byte)(number) -$46+(number) -$32 -- _deref_pbsc1=vbsc2
lda #-$46+-$32
sta SSCREEN+$28*3+1+1+1
// [18] *((const nomodify signed byte*) SSCREEN+++++++++(byte)(number) $28*(number) 3) ← (const signed byte) testSignedVals::sbc1+(signed byte) -$78 -- _deref_pbsc1=vbsc2
lda #sbc1+-$78
sta SSCREEN+$28*3+1+1+1+1
// [19] *((const nomodify signed byte*) SSCREEN+++++++++++(byte)(number) $28*(number) 3) ← (signed byte) -$78+(const signed byte) testSignedVals::sbc1 -- _deref_pbsc1=vbsc2
lda #-$78+sbc1
sta SSCREEN+$28*3+1+1+1+1+1
// [20] (signed byte~) testSignedVals::$2 ← (volatile signed byte) testSignedVals::sbv1 + (signed byte) -$78 -- vbsz1=vbsz2_plus_vbsc1
lax.z sbv1
axs #-[-$78]
stx.z __2
// [21] *((const nomodify signed byte*) SSCREEN+++++++++++++(byte)(number) $28*(number) 3) ← (signed byte~) testSignedVals::$2 -- _deref_pbsc1=vbsz1
lda.z __2
sta SSCREEN+$28*3+1+1+1+1+1+1
// [22] (signed byte~) testSignedVals::$3 ← (signed byte) -$78 + (volatile signed byte) testSignedVals::sbv1 -- vbsz1=vbsc1_plus_vbsz2
lax.z sbv1
axs #-[-$78]
stx.z __3
// [23] *((const nomodify signed byte*) SSCREEN+++++++++++++++(byte)(number) $28*(number) 3) ← (signed byte~) testSignedVals::$3 -- _deref_pbsc1=vbsz1
lda.z __3
sta SSCREEN+$28*3+1+1+1+1+1+1+1
// [24] (signed byte~) testSignedVals::$4 ← (volatile signed byte) testSignedVals::sbv1 + (const signed byte) testSignedVals::sbc1 -- vbsz1=vbsz2_plus_vbsc1
lax.z sbv1
axs #-[sbc1]
stx.z __4
// [25] *((const nomodify signed byte*) SSCREEN+++++++++++++++++(byte)(number) $28*(number) 3) ← (signed byte~) testSignedVals::$4 -- _deref_pbsc1=vbsz1
lda.z __4
sta SSCREEN+$28*3+1+1+1+1+1+1+1+1
// [26] (signed byte~) testSignedVals::$5 ← (const signed byte) testSignedVals::sbc1 + (volatile signed byte) testSignedVals::sbv1 -- vbsz1=vbsc1_plus_vbsz2
lax.z sbv1
axs #-[sbc1]
stx.z __5
// [27] *((const nomodify signed byte*) SSCREEN+++++++++++++++++++(byte)(number) $28*(number) 3) ← (signed byte~) testSignedVals::$5 -- _deref_pbsc1=vbsz1
lda.z __5
sta SSCREEN+$28*3+1+1+1+1+1+1+1+1+1
// [28] (signed byte~) testSignedVals::$6 ← (volatile signed byte) testSignedVals::sbv1 + (volatile signed byte) testSignedVals::sbv1 -- vbsz1=vbsz2_plus_vbsz2
lda.z sbv1
asl
sta.z __6
// [29] *((const nomodify signed byte*) SSCREEN+++++++++++++++++++++(byte)(number) $28*(number) 3) ← (signed byte~) testSignedVals::$6 -- _deref_pbsc1=vbsz1
lda.z __6
sta SSCREEN+$28*3+1+1+1+1+1+1+1+1+1+1
jmp __breturn
// testSignedVals::@return
__breturn:
// [30] return
rts
}
// testSigned
testSigned: {
// [31] *((const nomodify byte*) SCREEN+(byte)(number) $28*(number) 2) ← (byte) 0 -- _deref_pbuc1=vbuc2
lda #0
sta SCREEN+$28*2
// [32] *((const nomodify byte*) SCREEN+++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_SIGNED_BYTE
sta SCREEN+$28*2+1
// [33] *((const nomodify byte*) SCREEN+++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_SIGNED_BYTE
sta SCREEN+$28*2+1+1
// [34] *((const nomodify byte*) SCREEN+++++++(byte)(number) $28*(number) 2) ← (byte) 0 -- _deref_pbuc1=vbuc2
lda #0
sta SCREEN+$28*2+1+1+1
// [35] *((const nomodify byte*) SCREEN+++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_SIGNED_BYTE
sta SCREEN+$28*2+1+1+1+1
// [36] *((const nomodify byte*) SCREEN+++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_SIGNED_BYTE
sta SCREEN+$28*2+1+1+1+1+1
// [37] *((const nomodify byte*) SCREEN+++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_SIGNED_BYTE
sta SCREEN+$28*2+1+1+1+1+1+1
// [38] *((const nomodify byte*) SCREEN+++++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_SIGNED_BYTE
sta SCREEN+$28*2+1+1+1+1+1+1+1
// [39] *((const nomodify byte*) SCREEN+++++++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_SIGNED_BYTE
sta SCREEN+$28*2+1+1+1+1+1+1+1+1
// [40] *((const nomodify byte*) SCREEN+++++++++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_SIGNED_BYTE
sta SCREEN+$28*2+1+1+1+1+1+1+1+1+1
// [41] *((const nomodify byte*) SCREEN+++++++++++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_SIGNED_BYTE
sta SCREEN+$28*2+1+1+1+1+1+1+1+1+1+1
jmp __breturn
// testSigned::@return
__breturn:
// [42] return
rts
}
// testUnsignedVals
testUnsignedVals: {
.const ubc1 = $fa
.label ubv1 = 8
.label __2 = 9
.label __3 = $a
.label __4 = $b
.label __5 = $c
.label __6 = $d
// [43] (volatile byte) testUnsignedVals::ubv1 ← (byte) $fa -- vbuz1=vbuc1
lda #$fa
sta.z ubv1
// [44] *((const nomodify byte*) SCREEN+(byte) $28) ← (byte) $fa -- _deref_pbuc1=vbuc2
lda #$fa
sta SCREEN+$28
// [45] *((const nomodify byte*) SCREEN+(byte) $29) ← (const byte) testUnsignedVals::ubc1 -- _deref_pbuc1=vbuc2
lda #ubc1
sta SCREEN+$29
// [46] *((const nomodify byte*) SCREEN+(byte) $2a) ← (volatile byte) testUnsignedVals::ubv1 -- _deref_pbuc1=vbuz1
lda.z ubv1
sta SCREEN+$2a
// [47] *((const nomodify byte*) SCREEN+(byte) $2b) ← (byte)(number) $78+(number) $82 -- _deref_pbuc1=vbuc2
lda #$78+$82
sta SCREEN+$2b
// [48] *((const nomodify byte*) SCREEN+(byte) $2c) ← (const byte) testUnsignedVals::ubc1+(byte) $fa -- _deref_pbuc1=vbuc2
lda #ubc1+$fa
sta SCREEN+$2c
// [49] *((const nomodify byte*) SCREEN+(byte) $2d) ← (byte) $fa+(const byte) testUnsignedVals::ubc1 -- _deref_pbuc1=vbuc2
lda #$fa+ubc1
sta SCREEN+$2d
// [50] (byte~) testUnsignedVals::$2 ← (volatile byte) testUnsignedVals::ubv1 + (byte) $fa -- vbuz1=vbuz2_plus_vbuc1
lax.z ubv1
axs #-[$fa]
stx.z __2
// [51] *((const nomodify byte*) SCREEN+(byte) $2e) ← (byte~) testUnsignedVals::$2 -- _deref_pbuc1=vbuz1
lda.z __2
sta SCREEN+$2e
// [52] (byte~) testUnsignedVals::$3 ← (byte) $fa + (volatile byte) testUnsignedVals::ubv1 -- vbuz1=vbuc1_plus_vbuz2
lax.z ubv1
axs #-[$fa]
stx.z __3
// [53] *((const nomodify byte*) SCREEN+(byte) $2f) ← (byte~) testUnsignedVals::$3 -- _deref_pbuc1=vbuz1
lda.z __3
sta SCREEN+$2f
// [54] (byte~) testUnsignedVals::$4 ← (volatile byte) testUnsignedVals::ubv1 + (const byte) testUnsignedVals::ubc1 -- vbuz1=vbuz2_plus_vbuc1
lax.z ubv1
axs #-[ubc1]
stx.z __4
// [55] *((const nomodify byte*) SCREEN+(byte) $30) ← (byte~) testUnsignedVals::$4 -- _deref_pbuc1=vbuz1
lda.z __4
sta SCREEN+$30
// [56] (byte~) testUnsignedVals::$5 ← (const byte) testUnsignedVals::ubc1 + (volatile byte) testUnsignedVals::ubv1 -- vbuz1=vbuc1_plus_vbuz2
lax.z ubv1
axs #-[ubc1]
stx.z __5
// [57] *((const nomodify byte*) SCREEN+(byte) $31) ← (byte~) testUnsignedVals::$5 -- _deref_pbuc1=vbuz1
lda.z __5
sta SCREEN+$31
// [58] (byte~) testUnsignedVals::$6 ← (volatile byte) testUnsignedVals::ubv1 + (volatile byte) testUnsignedVals::ubv1 -- vbuz1=vbuz2_plus_vbuz2
lda.z ubv1
asl
sta.z __6
// [59] *((const nomodify byte*) SCREEN+(byte) $32) ← (byte~) testUnsignedVals::$6 -- _deref_pbuc1=vbuz1
lda.z __6
sta SCREEN+$32
jmp __breturn
// testUnsignedVals::@return
__breturn:
// [60] return
rts
}
// testUnsigned
testUnsigned: {
// [61] *((const nomodify byte*) SCREEN) ← (byte) 0 -- _deref_pbuc1=vbuc2
lda #0
sta SCREEN
// [62] *((const nomodify byte*) SCREEN+(byte) 1) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_BYTE
sta SCREEN+1
// [63] *((const nomodify byte*) SCREEN+(byte) 2) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_BYTE
sta SCREEN+2
// [64] *((const nomodify byte*) SCREEN+(byte) 3) ← (byte) 0 -- _deref_pbuc1=vbuc2
lda #0
sta SCREEN+3
// [65] *((const nomodify byte*) SCREEN+(byte) 4) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_BYTE
sta SCREEN+4
// [66] *((const nomodify byte*) SCREEN+(byte) 5) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_BYTE
sta SCREEN+5
// [67] *((const nomodify byte*) SCREEN+(byte) 6) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_BYTE
sta SCREEN+6
// [68] *((const nomodify byte*) SCREEN+(byte) 7) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_BYTE
sta SCREEN+7
// [69] *((const nomodify byte*) SCREEN+(byte) 8) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_BYTE
sta SCREEN+8
// [70] *((const nomodify byte*) SCREEN+(byte) 9) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_BYTE
sta SCREEN+9
// [71] *((const nomodify byte*) SCREEN+(byte) $a) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_BYTE
sta SCREEN+$a
jmp __breturn
// testUnsigned::@return
__breturn:
// [72] return
rts
}
// File Data
REGISTER UPLIFT POTENTIAL REGISTERS
Statement [13] (volatile signed byte) testSignedVals::sbv1 ← (signed byte) -$78 [ testSignedVals::sbv1 ] ( main:2::testSignedVals:11 [ testSignedVals::sbv1 ] { } ) always clobbers reg byte a
Statement [14] *((const nomodify signed byte*) SSCREEN+(byte)(number) $28*(number) 3) ← (signed byte) -$78 [ testSignedVals::sbv1 ] ( main:2::testSignedVals:11 [ testSignedVals::sbv1 ] { } ) always clobbers reg byte a
Statement [15] *((const nomodify signed byte*) SSCREEN+++(byte)(number) $28*(number) 3) ← (const signed byte) testSignedVals::sbc1 [ testSignedVals::sbv1 ] ( main:2::testSignedVals:11 [ testSignedVals::sbv1 ] { } ) always clobbers reg byte a
Statement [16] *((const nomodify signed byte*) SSCREEN+++++(byte)(number) $28*(number) 3) ← (volatile signed byte) testSignedVals::sbv1 [ testSignedVals::sbv1 ] ( main:2::testSignedVals:11 [ testSignedVals::sbv1 ] { } ) always clobbers reg byte a
Statement [17] *((const nomodify signed byte*) SSCREEN+++++++(byte)(number) $28*(number) 3) ← (signed byte)(number) -$46+(number) -$32 [ testSignedVals::sbv1 ] ( main:2::testSignedVals:11 [ testSignedVals::sbv1 ] { } ) always clobbers reg byte a
Statement [18] *((const nomodify signed byte*) SSCREEN+++++++++(byte)(number) $28*(number) 3) ← (const signed byte) testSignedVals::sbc1+(signed byte) -$78 [ testSignedVals::sbv1 ] ( main:2::testSignedVals:11 [ testSignedVals::sbv1 ] { } ) always clobbers reg byte a
Statement [19] *((const nomodify signed byte*) SSCREEN+++++++++++(byte)(number) $28*(number) 3) ← (signed byte) -$78+(const signed byte) testSignedVals::sbc1 [ testSignedVals::sbv1 ] ( main:2::testSignedVals:11 [ testSignedVals::sbv1 ] { } ) always clobbers reg byte a
Statement [20] (signed byte~) testSignedVals::$2 ← (volatile signed byte) testSignedVals::sbv1 + (signed byte) -$78 [ testSignedVals::sbv1 testSignedVals::$2 ] ( main:2::testSignedVals:11 [ testSignedVals::sbv1 testSignedVals::$2 ] { } ) always clobbers reg byte a
Statement [22] (signed byte~) testSignedVals::$3 ← (signed byte) -$78 + (volatile signed byte) testSignedVals::sbv1 [ testSignedVals::sbv1 testSignedVals::$3 ] ( main:2::testSignedVals:11 [ testSignedVals::sbv1 testSignedVals::$3 ] { } ) always clobbers reg byte a
Statement [24] (signed byte~) testSignedVals::$4 ← (volatile signed byte) testSignedVals::sbv1 + (const signed byte) testSignedVals::sbc1 [ testSignedVals::sbv1 testSignedVals::$4 ] ( main:2::testSignedVals:11 [ testSignedVals::sbv1 testSignedVals::$4 ] { } ) always clobbers reg byte a
Statement [26] (signed byte~) testSignedVals::$5 ← (const signed byte) testSignedVals::sbc1 + (volatile signed byte) testSignedVals::sbv1 [ testSignedVals::sbv1 testSignedVals::$5 ] ( main:2::testSignedVals:11 [ testSignedVals::sbv1 testSignedVals::$5 ] { } ) always clobbers reg byte a
Statement [28] (signed byte~) testSignedVals::$6 ← (volatile signed byte) testSignedVals::sbv1 + (volatile signed byte) testSignedVals::sbv1 [ testSignedVals::$6 ] ( main:2::testSignedVals:11 [ testSignedVals::$6 ] { } ) always clobbers reg byte a
Statement [31] *((const nomodify byte*) SCREEN+(byte)(number) $28*(number) 2) ← (byte) 0 [ ] ( main:2::testSigned:9 [ ] { } ) always clobbers reg byte a
Statement [32] *((const nomodify byte*) SCREEN+++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE [ ] ( main:2::testSigned:9 [ ] { } ) always clobbers reg byte a
Statement [33] *((const nomodify byte*) SCREEN+++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE [ ] ( main:2::testSigned:9 [ ] { } ) always clobbers reg byte a
Statement [34] *((const nomodify byte*) SCREEN+++++++(byte)(number) $28*(number) 2) ← (byte) 0 [ ] ( main:2::testSigned:9 [ ] { } ) always clobbers reg byte a
Statement [35] *((const nomodify byte*) SCREEN+++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE [ ] ( main:2::testSigned:9 [ ] { } ) always clobbers reg byte a
Statement [36] *((const nomodify byte*) SCREEN+++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE [ ] ( main:2::testSigned:9 [ ] { } ) always clobbers reg byte a
Statement [37] *((const nomodify byte*) SCREEN+++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE [ ] ( main:2::testSigned:9 [ ] { } ) always clobbers reg byte a
Statement [38] *((const nomodify byte*) SCREEN+++++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE [ ] ( main:2::testSigned:9 [ ] { } ) always clobbers reg byte a
Statement [39] *((const nomodify byte*) SCREEN+++++++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE [ ] ( main:2::testSigned:9 [ ] { } ) always clobbers reg byte a
Statement [40] *((const nomodify byte*) SCREEN+++++++++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE [ ] ( main:2::testSigned:9 [ ] { } ) always clobbers reg byte a
Statement [41] *((const nomodify byte*) SCREEN+++++++++++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE [ ] ( main:2::testSigned:9 [ ] { } ) always clobbers reg byte a
Statement [43] (volatile byte) testUnsignedVals::ubv1 ← (byte) $fa [ testUnsignedVals::ubv1 ] ( main:2::testUnsignedVals:7 [ testUnsignedVals::ubv1 ] { } ) always clobbers reg byte a
Statement [44] *((const nomodify byte*) SCREEN+(byte) $28) ← (byte) $fa [ testUnsignedVals::ubv1 ] ( main:2::testUnsignedVals:7 [ testUnsignedVals::ubv1 ] { } ) always clobbers reg byte a
Statement [45] *((const nomodify byte*) SCREEN+(byte) $29) ← (const byte) testUnsignedVals::ubc1 [ testUnsignedVals::ubv1 ] ( main:2::testUnsignedVals:7 [ testUnsignedVals::ubv1 ] { } ) always clobbers reg byte a
Statement [46] *((const nomodify byte*) SCREEN+(byte) $2a) ← (volatile byte) testUnsignedVals::ubv1 [ testUnsignedVals::ubv1 ] ( main:2::testUnsignedVals:7 [ testUnsignedVals::ubv1 ] { } ) always clobbers reg byte a
Statement [47] *((const nomodify byte*) SCREEN+(byte) $2b) ← (byte)(number) $78+(number) $82 [ testUnsignedVals::ubv1 ] ( main:2::testUnsignedVals:7 [ testUnsignedVals::ubv1 ] { } ) always clobbers reg byte a
Statement [48] *((const nomodify byte*) SCREEN+(byte) $2c) ← (const byte) testUnsignedVals::ubc1+(byte) $fa [ testUnsignedVals::ubv1 ] ( main:2::testUnsignedVals:7 [ testUnsignedVals::ubv1 ] { } ) always clobbers reg byte a
Statement [49] *((const nomodify byte*) SCREEN+(byte) $2d) ← (byte) $fa+(const byte) testUnsignedVals::ubc1 [ testUnsignedVals::ubv1 ] ( main:2::testUnsignedVals:7 [ testUnsignedVals::ubv1 ] { } ) always clobbers reg byte a
Statement [50] (byte~) testUnsignedVals::$2 ← (volatile byte) testUnsignedVals::ubv1 + (byte) $fa [ testUnsignedVals::ubv1 testUnsignedVals::$2 ] ( main:2::testUnsignedVals:7 [ testUnsignedVals::ubv1 testUnsignedVals::$2 ] { } ) always clobbers reg byte a
Statement [52] (byte~) testUnsignedVals::$3 ← (byte) $fa + (volatile byte) testUnsignedVals::ubv1 [ testUnsignedVals::ubv1 testUnsignedVals::$3 ] ( main:2::testUnsignedVals:7 [ testUnsignedVals::ubv1 testUnsignedVals::$3 ] { } ) always clobbers reg byte a
Statement [54] (byte~) testUnsignedVals::$4 ← (volatile byte) testUnsignedVals::ubv1 + (const byte) testUnsignedVals::ubc1 [ testUnsignedVals::ubv1 testUnsignedVals::$4 ] ( main:2::testUnsignedVals:7 [ testUnsignedVals::ubv1 testUnsignedVals::$4 ] { } ) always clobbers reg byte a
Statement [56] (byte~) testUnsignedVals::$5 ← (const byte) testUnsignedVals::ubc1 + (volatile byte) testUnsignedVals::ubv1 [ testUnsignedVals::ubv1 testUnsignedVals::$5 ] ( main:2::testUnsignedVals:7 [ testUnsignedVals::ubv1 testUnsignedVals::$5 ] { } ) always clobbers reg byte a
Statement [58] (byte~) testUnsignedVals::$6 ← (volatile byte) testUnsignedVals::ubv1 + (volatile byte) testUnsignedVals::ubv1 [ testUnsignedVals::$6 ] ( main:2::testUnsignedVals:7 [ testUnsignedVals::$6 ] { } ) always clobbers reg byte a
Statement [61] *((const nomodify byte*) SCREEN) ← (byte) 0 [ ] ( main:2::testUnsigned:5 [ ] { } ) always clobbers reg byte a
Statement [62] *((const nomodify byte*) SCREEN+(byte) 1) ← (const byte) TYPEID_BYTE [ ] ( main:2::testUnsigned:5 [ ] { } ) always clobbers reg byte a
Statement [63] *((const nomodify byte*) SCREEN+(byte) 2) ← (const byte) TYPEID_BYTE [ ] ( main:2::testUnsigned:5 [ ] { } ) always clobbers reg byte a
Statement [64] *((const nomodify byte*) SCREEN+(byte) 3) ← (byte) 0 [ ] ( main:2::testUnsigned:5 [ ] { } ) always clobbers reg byte a
Statement [65] *((const nomodify byte*) SCREEN+(byte) 4) ← (const byte) TYPEID_BYTE [ ] ( main:2::testUnsigned:5 [ ] { } ) always clobbers reg byte a
Statement [66] *((const nomodify byte*) SCREEN+(byte) 5) ← (const byte) TYPEID_BYTE [ ] ( main:2::testUnsigned:5 [ ] { } ) always clobbers reg byte a
Statement [67] *((const nomodify byte*) SCREEN+(byte) 6) ← (const byte) TYPEID_BYTE [ ] ( main:2::testUnsigned:5 [ ] { } ) always clobbers reg byte a
Statement [68] *((const nomodify byte*) SCREEN+(byte) 7) ← (const byte) TYPEID_BYTE [ ] ( main:2::testUnsigned:5 [ ] { } ) always clobbers reg byte a
Statement [69] *((const nomodify byte*) SCREEN+(byte) 8) ← (const byte) TYPEID_BYTE [ ] ( main:2::testUnsigned:5 [ ] { } ) always clobbers reg byte a
Statement [70] *((const nomodify byte*) SCREEN+(byte) 9) ← (const byte) TYPEID_BYTE [ ] ( main:2::testUnsigned:5 [ ] { } ) always clobbers reg byte a
Statement [71] *((const nomodify byte*) SCREEN+(byte) $a) ← (const byte) TYPEID_BYTE [ ] ( main:2::testUnsigned:5 [ ] { } ) always clobbers reg byte a
Potential registers zp[1]:2 [ testSignedVals::sbv1 ] : zp[1]:2 ,
Potential registers zp[1]:3 [ testSignedVals::$2 ] : zp[1]:3 , reg byte a , reg byte x , reg byte y ,
Potential registers zp[1]:4 [ testSignedVals::$3 ] : zp[1]:4 , reg byte a , reg byte x , reg byte y ,
Potential registers zp[1]:5 [ testSignedVals::$4 ] : zp[1]:5 , reg byte a , reg byte x , reg byte y ,
Potential registers zp[1]:6 [ testSignedVals::$5 ] : zp[1]:6 , reg byte a , reg byte x , reg byte y ,
Potential registers zp[1]:7 [ testSignedVals::$6 ] : zp[1]:7 , reg byte a , reg byte x , reg byte y ,
Potential registers zp[1]:8 [ testUnsignedVals::ubv1 ] : zp[1]:8 ,
Potential registers zp[1]:9 [ testUnsignedVals::$2 ] : zp[1]:9 , reg byte a , reg byte x , reg byte y ,
Potential registers zp[1]:10 [ testUnsignedVals::$3 ] : zp[1]:10 , reg byte a , reg byte x , reg byte y ,
Potential registers zp[1]:11 [ testUnsignedVals::$4 ] : zp[1]:11 , reg byte a , reg byte x , reg byte y ,
Potential registers zp[1]:12 [ testUnsignedVals::$5 ] : zp[1]:12 , reg byte a , reg byte x , reg byte y ,
Potential registers zp[1]:13 [ testUnsignedVals::$6 ] : zp[1]:13 , reg byte a , reg byte x , reg byte y ,
REGISTER UPLIFT SCOPES
Uplift Scope [testUnsignedVals] 202: zp[1]:9 [ testUnsignedVals::$2 ] 202: zp[1]:10 [ testUnsignedVals::$3 ] 202: zp[1]:11 [ testUnsignedVals::$4 ] 202: zp[1]:12 [ testUnsignedVals::$5 ] 202: zp[1]:13 [ testUnsignedVals::$6 ] 53.87: zp[1]:8 [ testUnsignedVals::ubv1 ]
Uplift Scope [testSignedVals] 202: zp[1]:3 [ testSignedVals::$2 ] 202: zp[1]:4 [ testSignedVals::$3 ] 202: zp[1]:5 [ testSignedVals::$4 ] 202: zp[1]:6 [ testSignedVals::$5 ] 202: zp[1]:7 [ testSignedVals::$6 ] 53.87: zp[1]:2 [ testSignedVals::sbv1 ]
Uplift Scope [main]
Uplift Scope [testUnsigned]
Uplift Scope [testSigned]
Uplift Scope []
Uplifting [testUnsignedVals] best 436 combination reg byte x [ testUnsignedVals::$2 ] reg byte x [ testUnsignedVals::$3 ] reg byte a [ testUnsignedVals::$4 ] reg byte a [ testUnsignedVals::$5 ] zp[1]:13 [ testUnsignedVals::$6 ] zp[1]:8 [ testUnsignedVals::ubv1 ]
Limited combination testing to 100 combinations of 1024 possible.
Uplifting [testSignedVals] best 420 combination reg byte a [ testSignedVals::$2 ] reg byte a [ testSignedVals::$3 ] reg byte a [ testSignedVals::$4 ] reg byte a [ testSignedVals::$5 ] zp[1]:7 [ testSignedVals::$6 ] zp[1]:2 [ testSignedVals::sbv1 ]
Limited combination testing to 100 combinations of 1024 possible.
Uplifting [main] best 420 combination
Uplifting [testUnsigned] best 420 combination
Uplifting [testSigned] best 420 combination
Uplifting [] best 420 combination
Attempting to uplift remaining variables inzp[1]:7 [ testSignedVals::$6 ]
Uplifting [testSignedVals] best 414 combination reg byte a [ testSignedVals::$6 ]
Attempting to uplift remaining variables inzp[1]:13 [ testUnsignedVals::$6 ]
Uplifting [testUnsignedVals] best 408 combination reg byte a [ testUnsignedVals::$6 ]
Attempting to uplift remaining variables inzp[1]:2 [ testSignedVals::sbv1 ]
Uplifting [testSignedVals] best 408 combination zp[1]:2 [ testSignedVals::sbv1 ]
Attempting to uplift remaining variables inzp[1]:8 [ testUnsignedVals::ubv1 ]
Uplifting [testUnsignedVals] best 408 combination zp[1]:8 [ testUnsignedVals::ubv1 ]
Allocated (was zp[1]:8) zp[1]:3 [ testUnsignedVals::ubv1 ]
ASSEMBLER BEFORE OPTIMIZATION
// File Comments
// Test that plus creates the expected type for all legal combinations of bytes (signed/unsigned - constant/variable)
// Upstart
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
// Global Constants & labels
.const TYPEID_BYTE = 1
.const TYPEID_SIGNED_BYTE = 2
.label SCREEN = $400
.label SSCREEN = $400
// @begin
__bbegin:
// [1] phi from @begin to @1 [phi:@begin->@1]
__b1_from___bbegin:
jmp __b1
// @1
__b1:
// [2] call main
// [4] phi from @1 to main [phi:@1->main]
main_from___b1:
jsr main
// [3] phi from @1 to @end [phi:@1->@end]
__bend_from___b1:
jmp __bend
// @end
__bend:
// main
main: {
// [5] call testUnsigned
jsr testUnsigned
// [6] phi from main to main::@1 [phi:main->main::@1]
__b1_from_main:
jmp __b1
// main::@1
__b1:
// [7] call testUnsignedVals
jsr testUnsignedVals
// [8] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
__b2_from___b1:
jmp __b2
// main::@2
__b2:
// [9] call testSigned
jsr testSigned
// [10] phi from main::@2 to main::@3 [phi:main::@2->main::@3]
__b3_from___b2:
jmp __b3
// main::@3
__b3:
// [11] call testSignedVals
jsr testSignedVals
jmp __breturn
// main::@return
__breturn:
// [12] return
rts
}
// testSignedVals
testSignedVals: {
.const sbc1 = -$78
.label sbv1 = 2
// [13] (volatile signed byte) testSignedVals::sbv1 ← (signed byte) -$78 -- vbsz1=vbsc1
lda #-$78
sta.z sbv1
// [14] *((const nomodify signed byte*) SSCREEN+(byte)(number) $28*(number) 3) ← (signed byte) -$78 -- _deref_pbsc1=vbsc2
lda #-$78
sta SSCREEN+$28*3
// [15] *((const nomodify signed byte*) SSCREEN+++(byte)(number) $28*(number) 3) ← (const signed byte) testSignedVals::sbc1 -- _deref_pbsc1=vbsc2
lda #sbc1
sta SSCREEN+$28*3+1
// [16] *((const nomodify signed byte*) SSCREEN+++++(byte)(number) $28*(number) 3) ← (volatile signed byte) testSignedVals::sbv1 -- _deref_pbsc1=vbsz1
lda.z sbv1
sta SSCREEN+$28*3+1+1
// [17] *((const nomodify signed byte*) SSCREEN+++++++(byte)(number) $28*(number) 3) ← (signed byte)(number) -$46+(number) -$32 -- _deref_pbsc1=vbsc2
lda #-$46+-$32
sta SSCREEN+$28*3+1+1+1
// [18] *((const nomodify signed byte*) SSCREEN+++++++++(byte)(number) $28*(number) 3) ← (const signed byte) testSignedVals::sbc1+(signed byte) -$78 -- _deref_pbsc1=vbsc2
lda #sbc1+-$78
sta SSCREEN+$28*3+1+1+1+1
// [19] *((const nomodify signed byte*) SSCREEN+++++++++++(byte)(number) $28*(number) 3) ← (signed byte) -$78+(const signed byte) testSignedVals::sbc1 -- _deref_pbsc1=vbsc2
lda #-$78+sbc1
sta SSCREEN+$28*3+1+1+1+1+1
// [20] (signed byte~) testSignedVals::$2 ← (volatile signed byte) testSignedVals::sbv1 + (signed byte) -$78 -- vbsaa=vbsz1_plus_vbsc1
lda #-$78
clc
adc.z sbv1
// [21] *((const nomodify signed byte*) SSCREEN+++++++++++++(byte)(number) $28*(number) 3) ← (signed byte~) testSignedVals::$2 -- _deref_pbsc1=vbsaa
sta SSCREEN+$28*3+1+1+1+1+1+1
// [22] (signed byte~) testSignedVals::$3 ← (signed byte) -$78 + (volatile signed byte) testSignedVals::sbv1 -- vbsaa=vbsc1_plus_vbsz1
lda #-$78
clc
adc.z sbv1
// [23] *((const nomodify signed byte*) SSCREEN+++++++++++++++(byte)(number) $28*(number) 3) ← (signed byte~) testSignedVals::$3 -- _deref_pbsc1=vbsaa
sta SSCREEN+$28*3+1+1+1+1+1+1+1
// [24] (signed byte~) testSignedVals::$4 ← (volatile signed byte) testSignedVals::sbv1 + (const signed byte) testSignedVals::sbc1 -- vbsaa=vbsz1_plus_vbsc1
lda #sbc1
clc
adc.z sbv1
// [25] *((const nomodify signed byte*) SSCREEN+++++++++++++++++(byte)(number) $28*(number) 3) ← (signed byte~) testSignedVals::$4 -- _deref_pbsc1=vbsaa
sta SSCREEN+$28*3+1+1+1+1+1+1+1+1
// [26] (signed byte~) testSignedVals::$5 ← (const signed byte) testSignedVals::sbc1 + (volatile signed byte) testSignedVals::sbv1 -- vbsaa=vbsc1_plus_vbsz1
lda #sbc1
clc
adc.z sbv1
// [27] *((const nomodify signed byte*) SSCREEN+++++++++++++++++++(byte)(number) $28*(number) 3) ← (signed byte~) testSignedVals::$5 -- _deref_pbsc1=vbsaa
sta SSCREEN+$28*3+1+1+1+1+1+1+1+1+1
// [28] (signed byte~) testSignedVals::$6 ← (volatile signed byte) testSignedVals::sbv1 + (volatile signed byte) testSignedVals::sbv1 -- vbsaa=vbsz1_plus_vbsz1
lda.z sbv1
asl
// [29] *((const nomodify signed byte*) SSCREEN+++++++++++++++++++++(byte)(number) $28*(number) 3) ← (signed byte~) testSignedVals::$6 -- _deref_pbsc1=vbsaa
sta SSCREEN+$28*3+1+1+1+1+1+1+1+1+1+1
jmp __breturn
// testSignedVals::@return
__breturn:
// [30] return
rts
}
// testSigned
testSigned: {
// [31] *((const nomodify byte*) SCREEN+(byte)(number) $28*(number) 2) ← (byte) 0 -- _deref_pbuc1=vbuc2
lda #0
sta SCREEN+$28*2
// [32] *((const nomodify byte*) SCREEN+++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_SIGNED_BYTE
sta SCREEN+$28*2+1
// [33] *((const nomodify byte*) SCREEN+++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_SIGNED_BYTE
sta SCREEN+$28*2+1+1
// [34] *((const nomodify byte*) SCREEN+++++++(byte)(number) $28*(number) 2) ← (byte) 0 -- _deref_pbuc1=vbuc2
lda #0
sta SCREEN+$28*2+1+1+1
// [35] *((const nomodify byte*) SCREEN+++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_SIGNED_BYTE
sta SCREEN+$28*2+1+1+1+1
// [36] *((const nomodify byte*) SCREEN+++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_SIGNED_BYTE
sta SCREEN+$28*2+1+1+1+1+1
// [37] *((const nomodify byte*) SCREEN+++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_SIGNED_BYTE
sta SCREEN+$28*2+1+1+1+1+1+1
// [38] *((const nomodify byte*) SCREEN+++++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_SIGNED_BYTE
sta SCREEN+$28*2+1+1+1+1+1+1+1
// [39] *((const nomodify byte*) SCREEN+++++++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_SIGNED_BYTE
sta SCREEN+$28*2+1+1+1+1+1+1+1+1
// [40] *((const nomodify byte*) SCREEN+++++++++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_SIGNED_BYTE
sta SCREEN+$28*2+1+1+1+1+1+1+1+1+1
// [41] *((const nomodify byte*) SCREEN+++++++++++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_SIGNED_BYTE
sta SCREEN+$28*2+1+1+1+1+1+1+1+1+1+1
jmp __breturn
// testSigned::@return
__breturn:
// [42] return
rts
}
// testUnsignedVals
testUnsignedVals: {
.const ubc1 = $fa
.label ubv1 = 3
// [43] (volatile byte) testUnsignedVals::ubv1 ← (byte) $fa -- vbuz1=vbuc1
lda #$fa
sta.z ubv1
// [44] *((const nomodify byte*) SCREEN+(byte) $28) ← (byte) $fa -- _deref_pbuc1=vbuc2
lda #$fa
sta SCREEN+$28
// [45] *((const nomodify byte*) SCREEN+(byte) $29) ← (const byte) testUnsignedVals::ubc1 -- _deref_pbuc1=vbuc2
lda #ubc1
sta SCREEN+$29
// [46] *((const nomodify byte*) SCREEN+(byte) $2a) ← (volatile byte) testUnsignedVals::ubv1 -- _deref_pbuc1=vbuz1
lda.z ubv1
sta SCREEN+$2a
// [47] *((const nomodify byte*) SCREEN+(byte) $2b) ← (byte)(number) $78+(number) $82 -- _deref_pbuc1=vbuc2
lda #$78+$82
sta SCREEN+$2b
// [48] *((const nomodify byte*) SCREEN+(byte) $2c) ← (const byte) testUnsignedVals::ubc1+(byte) $fa -- _deref_pbuc1=vbuc2
lda #ubc1+$fa
sta SCREEN+$2c
// [49] *((const nomodify byte*) SCREEN+(byte) $2d) ← (byte) $fa+(const byte) testUnsignedVals::ubc1 -- _deref_pbuc1=vbuc2
lda #$fa+ubc1
sta SCREEN+$2d
// [50] (byte~) testUnsignedVals::$2 ← (volatile byte) testUnsignedVals::ubv1 + (byte) $fa -- vbuxx=vbuz1_plus_vbuc1
lax.z ubv1
axs #-[$fa]
// [51] *((const nomodify byte*) SCREEN+(byte) $2e) ← (byte~) testUnsignedVals::$2 -- _deref_pbuc1=vbuxx
stx SCREEN+$2e
// [52] (byte~) testUnsignedVals::$3 ← (byte) $fa + (volatile byte) testUnsignedVals::ubv1 -- vbuxx=vbuc1_plus_vbuz1
lax.z ubv1
axs #-[$fa]
// [53] *((const nomodify byte*) SCREEN+(byte) $2f) ← (byte~) testUnsignedVals::$3 -- _deref_pbuc1=vbuxx
stx SCREEN+$2f
// [54] (byte~) testUnsignedVals::$4 ← (volatile byte) testUnsignedVals::ubv1 + (const byte) testUnsignedVals::ubc1 -- vbuaa=vbuz1_plus_vbuc1
lda #ubc1
clc
adc.z ubv1
// [55] *((const nomodify byte*) SCREEN+(byte) $30) ← (byte~) testUnsignedVals::$4 -- _deref_pbuc1=vbuaa
sta SCREEN+$30
// [56] (byte~) testUnsignedVals::$5 ← (const byte) testUnsignedVals::ubc1 + (volatile byte) testUnsignedVals::ubv1 -- vbuaa=vbuc1_plus_vbuz1
lda #ubc1
clc
adc.z ubv1
// [57] *((const nomodify byte*) SCREEN+(byte) $31) ← (byte~) testUnsignedVals::$5 -- _deref_pbuc1=vbuaa
sta SCREEN+$31
// [58] (byte~) testUnsignedVals::$6 ← (volatile byte) testUnsignedVals::ubv1 + (volatile byte) testUnsignedVals::ubv1 -- vbuaa=vbuz1_plus_vbuz1
lda.z ubv1
asl
// [59] *((const nomodify byte*) SCREEN+(byte) $32) ← (byte~) testUnsignedVals::$6 -- _deref_pbuc1=vbuaa
sta SCREEN+$32
jmp __breturn
// testUnsignedVals::@return
__breturn:
// [60] return
rts
}
// testUnsigned
testUnsigned: {
// [61] *((const nomodify byte*) SCREEN) ← (byte) 0 -- _deref_pbuc1=vbuc2
lda #0
sta SCREEN
// [62] *((const nomodify byte*) SCREEN+(byte) 1) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_BYTE
sta SCREEN+1
// [63] *((const nomodify byte*) SCREEN+(byte) 2) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_BYTE
sta SCREEN+2
// [64] *((const nomodify byte*) SCREEN+(byte) 3) ← (byte) 0 -- _deref_pbuc1=vbuc2
lda #0
sta SCREEN+3
// [65] *((const nomodify byte*) SCREEN+(byte) 4) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_BYTE
sta SCREEN+4
// [66] *((const nomodify byte*) SCREEN+(byte) 5) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_BYTE
sta SCREEN+5
// [67] *((const nomodify byte*) SCREEN+(byte) 6) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_BYTE
sta SCREEN+6
// [68] *((const nomodify byte*) SCREEN+(byte) 7) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_BYTE
sta SCREEN+7
// [69] *((const nomodify byte*) SCREEN+(byte) 8) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_BYTE
sta SCREEN+8
// [70] *((const nomodify byte*) SCREEN+(byte) 9) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_BYTE
sta SCREEN+9
// [71] *((const nomodify byte*) SCREEN+(byte) $a) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_BYTE
sta SCREEN+$a
jmp __breturn
// testUnsigned::@return
__breturn:
// [72] return
rts
}
// File Data
ASSEMBLER OPTIMIZATIONS
Removing instruction jmp __b1
Removing instruction jmp __bend
Removing instruction jmp __b1
Removing instruction jmp __b2
Removing instruction jmp __b3
Removing instruction jmp __breturn
Removing instruction jmp __breturn
Removing instruction jmp __breturn
Removing instruction jmp __breturn
Removing instruction jmp __breturn
Succesful ASM optimization Pass5NextJumpElimination
Removing instruction lda #-$78
Removing instruction lda #TYPEID_SIGNED_BYTE
Removing instruction lda #TYPEID_SIGNED_BYTE
Removing instruction lda #TYPEID_SIGNED_BYTE
Removing instruction lda #TYPEID_SIGNED_BYTE
Removing instruction lda #TYPEID_SIGNED_BYTE
Removing instruction lda #TYPEID_SIGNED_BYTE
Removing instruction lda #TYPEID_SIGNED_BYTE
Removing instruction lda #$fa
Removing instruction lda #TYPEID_BYTE
Removing instruction lda #TYPEID_BYTE
Removing instruction lda #TYPEID_BYTE
Removing instruction lda #TYPEID_BYTE
Removing instruction lda #TYPEID_BYTE
Removing instruction lda #TYPEID_BYTE
Removing instruction lda #TYPEID_BYTE
Succesful ASM optimization Pass5UnnecesaryLoadElimination
Removing instruction __b1_from___bbegin:
Removing instruction __b1:
Removing instruction main_from___b1:
Removing instruction __bend_from___b1:
Removing instruction __b1_from_main:
Removing instruction __b2_from___b1:
Removing instruction __b3_from___b2:
Succesful ASM optimization Pass5RedundantLabelElimination
Removing instruction __bbegin:
Removing instruction __bend:
Removing instruction __b1:
Removing instruction __b2:
Removing instruction __b3:
Removing instruction __breturn:
Removing instruction __breturn:
Removing instruction __breturn:
Removing instruction __breturn:
Removing instruction __breturn:
Succesful ASM optimization Pass5UnusedLabelElimination
Removing instruction jsr main
Succesful ASM optimization Pass5SkipBegin
FINAL SYMBOL TABLE
(label) @1
(label) @begin
(label) @end
(const nomodify byte*) SCREEN = (byte*) 1024
(const nomodify signed byte*) SSCREEN = (signed byte*) 1024
(const byte) TYPEID_BYTE = (number) 1
(const byte) TYPEID_SIGNED_BYTE = (number) 2
(byte) idx
(void()) main()
(label) main::@1
(label) main::@2
(label) main::@3
(label) main::@return
(void()) testSigned()
(label) testSigned::@return
(void()) testSignedVals()
(signed byte~) testSignedVals::$2 reg byte a 202.0
(signed byte~) testSignedVals::$3 reg byte a 202.0
(signed byte~) testSignedVals::$4 reg byte a 202.0
(signed byte~) testSignedVals::$5 reg byte a 202.0
(signed byte~) testSignedVals::$6 reg byte a 202.0
(label) testSignedVals::@return
(const signed byte) testSignedVals::sbc1 = (signed byte) -$78
(volatile signed byte) testSignedVals::sbv1 loadstore zp[1]:2 53.86666666666667
(void()) testUnsigned()
(label) testUnsigned::@return
(void()) testUnsignedVals()
(byte~) testUnsignedVals::$2 reg byte x 202.0
(byte~) testUnsignedVals::$3 reg byte x 202.0
(byte~) testUnsignedVals::$4 reg byte a 202.0
(byte~) testUnsignedVals::$5 reg byte a 202.0
(byte~) testUnsignedVals::$6 reg byte a 202.0
(label) testUnsignedVals::@return
(const byte) testUnsignedVals::ubc1 = (byte) $fa
(volatile byte) testUnsignedVals::ubv1 loadstore zp[1]:3 53.86666666666667
zp[1]:2 [ testSignedVals::sbv1 ]
reg byte a [ testSignedVals::$2 ]
reg byte a [ testSignedVals::$3 ]
reg byte a [ testSignedVals::$4 ]
reg byte a [ testSignedVals::$5 ]
reg byte a [ testSignedVals::$6 ]
zp[1]:3 [ testUnsignedVals::ubv1 ]
reg byte x [ testUnsignedVals::$2 ]
reg byte x [ testUnsignedVals::$3 ]
reg byte a [ testUnsignedVals::$4 ]
reg byte a [ testUnsignedVals::$5 ]
reg byte a [ testUnsignedVals::$6 ]
FINAL ASSEMBLER
Score: 340
// File Comments
// Test that plus creates the expected type for all legal combinations of bytes (signed/unsigned - constant/variable)
// Upstart
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
// Global Constants & labels
.const TYPEID_BYTE = 1
.const TYPEID_SIGNED_BYTE = 2
.label SCREEN = $400
.label SSCREEN = $400
// @begin
// [1] phi from @begin to @1 [phi:@begin->@1]
// @1
// [2] call main
// [4] phi from @1 to main [phi:@1->main]
// [3] phi from @1 to @end [phi:@1->@end]
// @end
// main
main: {
// testUnsigned()
// [5] call testUnsigned
jsr testUnsigned
// [6] phi from main to main::@1 [phi:main->main::@1]
// main::@1
// testUnsignedVals()
// [7] call testUnsignedVals
jsr testUnsignedVals
// [8] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
// main::@2
// testSigned()
// [9] call testSigned
jsr testSigned
// [10] phi from main::@2 to main::@3 [phi:main::@2->main::@3]
// main::@3
// testSignedVals()
// [11] call testSignedVals
jsr testSignedVals
// main::@return
// }
// [12] return
rts
}
// testSignedVals
testSignedVals: {
.const sbc1 = -$78
.label sbv1 = 2
// sbv1 = -120
// [13] (volatile signed byte) testSignedVals::sbv1 ← (signed byte) -$78 -- vbsz1=vbsc1
lda #-$78
sta.z sbv1
// SSCREEN[idx++] = (-120)
// [14] *((const nomodify signed byte*) SSCREEN+(byte)(number) $28*(number) 3) ← (signed byte) -$78 -- _deref_pbsc1=vbsc2
sta SSCREEN+$28*3
// SSCREEN[idx++] = (sbc1)
// [15] *((const nomodify signed byte*) SSCREEN+++(byte)(number) $28*(number) 3) ← (const signed byte) testSignedVals::sbc1 -- _deref_pbsc1=vbsc2
lda #sbc1
sta SSCREEN+$28*3+1
// SSCREEN[idx++] = (sbv1)
// [16] *((const nomodify signed byte*) SSCREEN+++++(byte)(number) $28*(number) 3) ← (volatile signed byte) testSignedVals::sbv1 -- _deref_pbsc1=vbsz1
lda.z sbv1
sta SSCREEN+$28*3+1+1
// SSCREEN[idx++] = (-70+-50)
// [17] *((const nomodify signed byte*) SSCREEN+++++++(byte)(number) $28*(number) 3) ← (signed byte)(number) -$46+(number) -$32 -- _deref_pbsc1=vbsc2
lda #-$46+-$32
sta SSCREEN+$28*3+1+1+1
// SSCREEN[idx++] = (sbc1+-120)
// [18] *((const nomodify signed byte*) SSCREEN+++++++++(byte)(number) $28*(number) 3) ← (const signed byte) testSignedVals::sbc1+(signed byte) -$78 -- _deref_pbsc1=vbsc2
lda #sbc1+-$78
sta SSCREEN+$28*3+1+1+1+1
// SSCREEN[idx++] = (-120+sbc1)
// [19] *((const nomodify signed byte*) SSCREEN+++++++++++(byte)(number) $28*(number) 3) ← (signed byte) -$78+(const signed byte) testSignedVals::sbc1 -- _deref_pbsc1=vbsc2
lda #-$78+sbc1
sta SSCREEN+$28*3+1+1+1+1+1
// sbv1+-120
// [20] (signed byte~) testSignedVals::$2 ← (volatile signed byte) testSignedVals::sbv1 + (signed byte) -$78 -- vbsaa=vbsz1_plus_vbsc1
lda #-$78
clc
adc.z sbv1
// SSCREEN[idx++] = (sbv1+-120)
// [21] *((const nomodify signed byte*) SSCREEN+++++++++++++(byte)(number) $28*(number) 3) ← (signed byte~) testSignedVals::$2 -- _deref_pbsc1=vbsaa
sta SSCREEN+$28*3+1+1+1+1+1+1
// -120+sbv1
// [22] (signed byte~) testSignedVals::$3 ← (signed byte) -$78 + (volatile signed byte) testSignedVals::sbv1 -- vbsaa=vbsc1_plus_vbsz1
lda #-$78
clc
adc.z sbv1
// SSCREEN[idx++] = (-120+sbv1)
// [23] *((const nomodify signed byte*) SSCREEN+++++++++++++++(byte)(number) $28*(number) 3) ← (signed byte~) testSignedVals::$3 -- _deref_pbsc1=vbsaa
sta SSCREEN+$28*3+1+1+1+1+1+1+1
// sbv1+sbc1
// [24] (signed byte~) testSignedVals::$4 ← (volatile signed byte) testSignedVals::sbv1 + (const signed byte) testSignedVals::sbc1 -- vbsaa=vbsz1_plus_vbsc1
lda #sbc1
clc
adc.z sbv1
// SSCREEN[idx++] = (sbv1+sbc1)
// [25] *((const nomodify signed byte*) SSCREEN+++++++++++++++++(byte)(number) $28*(number) 3) ← (signed byte~) testSignedVals::$4 -- _deref_pbsc1=vbsaa
sta SSCREEN+$28*3+1+1+1+1+1+1+1+1
// sbc1+sbv1
// [26] (signed byte~) testSignedVals::$5 ← (const signed byte) testSignedVals::sbc1 + (volatile signed byte) testSignedVals::sbv1 -- vbsaa=vbsc1_plus_vbsz1
lda #sbc1
clc
adc.z sbv1
// SSCREEN[idx++] = (sbc1+sbv1)
// [27] *((const nomodify signed byte*) SSCREEN+++++++++++++++++++(byte)(number) $28*(number) 3) ← (signed byte~) testSignedVals::$5 -- _deref_pbsc1=vbsaa
sta SSCREEN+$28*3+1+1+1+1+1+1+1+1+1
// sbv1+sbv1
// [28] (signed byte~) testSignedVals::$6 ← (volatile signed byte) testSignedVals::sbv1 + (volatile signed byte) testSignedVals::sbv1 -- vbsaa=vbsz1_plus_vbsz1
lda.z sbv1
asl
// SSCREEN[idx++] = (sbv1+sbv1)
// [29] *((const nomodify signed byte*) SSCREEN+++++++++++++++++++++(byte)(number) $28*(number) 3) ← (signed byte~) testSignedVals::$6 -- _deref_pbsc1=vbsaa
sta SSCREEN+$28*3+1+1+1+1+1+1+1+1+1+1
// testSignedVals::@return
// }
// [30] return
rts
}
// testSigned
testSigned: {
// SCREEN[idx++] = typeid(-120)
// [31] *((const nomodify byte*) SCREEN+(byte)(number) $28*(number) 2) ← (byte) 0 -- _deref_pbuc1=vbuc2
lda #0
sta SCREEN+$28*2
// SCREEN[idx++] = typeid(sbc1)
// [32] *((const nomodify byte*) SCREEN+++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_SIGNED_BYTE
sta SCREEN+$28*2+1
// SCREEN[idx++] = typeid(sbv1)
// [33] *((const nomodify byte*) SCREEN+++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
sta SCREEN+$28*2+1+1
// SCREEN[idx++] = typeid(-120+-130)
// [34] *((const nomodify byte*) SCREEN+++++++(byte)(number) $28*(number) 2) ← (byte) 0 -- _deref_pbuc1=vbuc2
lda #0
sta SCREEN+$28*2+1+1+1
// SCREEN[idx++] = typeid(sbc1+-120)
// [35] *((const nomodify byte*) SCREEN+++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_SIGNED_BYTE
sta SCREEN+$28*2+1+1+1+1
// SCREEN[idx++] = typeid(-120+sbc1)
// [36] *((const nomodify byte*) SCREEN+++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
sta SCREEN+$28*2+1+1+1+1+1
// SCREEN[idx++] = typeid(sbv1+-120)
// [37] *((const nomodify byte*) SCREEN+++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
sta SCREEN+$28*2+1+1+1+1+1+1
// SCREEN[idx++] = typeid(-120+sbv1)
// [38] *((const nomodify byte*) SCREEN+++++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
sta SCREEN+$28*2+1+1+1+1+1+1+1
// SCREEN[idx++] = typeid(sbv1+sbc1)
// [39] *((const nomodify byte*) SCREEN+++++++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
sta SCREEN+$28*2+1+1+1+1+1+1+1+1
// SCREEN[idx++] = typeid(sbc1+sbv1)
// [40] *((const nomodify byte*) SCREEN+++++++++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
sta SCREEN+$28*2+1+1+1+1+1+1+1+1+1
// SCREEN[idx++] = typeid(sbv1+sbv1)
// [41] *((const nomodify byte*) SCREEN+++++++++++++++++++++(byte)(number) $28*(number) 2) ← (const byte) TYPEID_SIGNED_BYTE -- _deref_pbuc1=vbuc2
sta SCREEN+$28*2+1+1+1+1+1+1+1+1+1+1
// testSigned::@return
// }
// [42] return
rts
}
// testUnsignedVals
testUnsignedVals: {
.const ubc1 = $fa
.label ubv1 = 3
// ubv1 = 250
// [43] (volatile byte) testUnsignedVals::ubv1 ← (byte) $fa -- vbuz1=vbuc1
lda #$fa
sta.z ubv1
// SCREEN[idx++] = 250
// [44] *((const nomodify byte*) SCREEN+(byte) $28) ← (byte) $fa -- _deref_pbuc1=vbuc2
sta SCREEN+$28
// SCREEN[idx++] = ubc1
// [45] *((const nomodify byte*) SCREEN+(byte) $29) ← (const byte) testUnsignedVals::ubc1 -- _deref_pbuc1=vbuc2
lda #ubc1
sta SCREEN+$29
// SCREEN[idx++] = ubv1
// [46] *((const nomodify byte*) SCREEN+(byte) $2a) ← (volatile byte) testUnsignedVals::ubv1 -- _deref_pbuc1=vbuz1
lda.z ubv1
sta SCREEN+$2a
// SCREEN[idx++] = 120+130
// [47] *((const nomodify byte*) SCREEN+(byte) $2b) ← (byte)(number) $78+(number) $82 -- _deref_pbuc1=vbuc2
lda #$78+$82
sta SCREEN+$2b
// SCREEN[idx++] = ubc1+250
// [48] *((const nomodify byte*) SCREEN+(byte) $2c) ← (const byte) testUnsignedVals::ubc1+(byte) $fa -- _deref_pbuc1=vbuc2
lda #ubc1+$fa
sta SCREEN+$2c
// SCREEN[idx++] = 250+ubc1
// [49] *((const nomodify byte*) SCREEN+(byte) $2d) ← (byte) $fa+(const byte) testUnsignedVals::ubc1 -- _deref_pbuc1=vbuc2
lda #$fa+ubc1
sta SCREEN+$2d
// ubv1+250
// [50] (byte~) testUnsignedVals::$2 ← (volatile byte) testUnsignedVals::ubv1 + (byte) $fa -- vbuxx=vbuz1_plus_vbuc1
lax.z ubv1
axs #-[$fa]
// SCREEN[idx++] = ubv1+250
// [51] *((const nomodify byte*) SCREEN+(byte) $2e) ← (byte~) testUnsignedVals::$2 -- _deref_pbuc1=vbuxx
stx SCREEN+$2e
// 250+ubv1
// [52] (byte~) testUnsignedVals::$3 ← (byte) $fa + (volatile byte) testUnsignedVals::ubv1 -- vbuxx=vbuc1_plus_vbuz1
lax.z ubv1
axs #-[$fa]
// SCREEN[idx++] = 250+ubv1
// [53] *((const nomodify byte*) SCREEN+(byte) $2f) ← (byte~) testUnsignedVals::$3 -- _deref_pbuc1=vbuxx
stx SCREEN+$2f
// ubv1+ubc1
// [54] (byte~) testUnsignedVals::$4 ← (volatile byte) testUnsignedVals::ubv1 + (const byte) testUnsignedVals::ubc1 -- vbuaa=vbuz1_plus_vbuc1
lda #ubc1
clc
adc.z ubv1
// SCREEN[idx++] = ubv1+ubc1
// [55] *((const nomodify byte*) SCREEN+(byte) $30) ← (byte~) testUnsignedVals::$4 -- _deref_pbuc1=vbuaa
sta SCREEN+$30
// ubc1+ubv1
// [56] (byte~) testUnsignedVals::$5 ← (const byte) testUnsignedVals::ubc1 + (volatile byte) testUnsignedVals::ubv1 -- vbuaa=vbuc1_plus_vbuz1
lda #ubc1
clc
adc.z ubv1
// SCREEN[idx++] = ubc1+ubv1
// [57] *((const nomodify byte*) SCREEN+(byte) $31) ← (byte~) testUnsignedVals::$5 -- _deref_pbuc1=vbuaa
sta SCREEN+$31
// ubv1+ubv1
// [58] (byte~) testUnsignedVals::$6 ← (volatile byte) testUnsignedVals::ubv1 + (volatile byte) testUnsignedVals::ubv1 -- vbuaa=vbuz1_plus_vbuz1
lda.z ubv1
asl
// SCREEN[idx++] = ubv1+ubv1
// [59] *((const nomodify byte*) SCREEN+(byte) $32) ← (byte~) testUnsignedVals::$6 -- _deref_pbuc1=vbuaa
sta SCREEN+$32
// testUnsignedVals::@return
// }
// [60] return
rts
}
// testUnsigned
testUnsigned: {
// SCREEN[idx++] = typeid(250)
// [61] *((const nomodify byte*) SCREEN) ← (byte) 0 -- _deref_pbuc1=vbuc2
lda #0
sta SCREEN
// SCREEN[idx++] = typeid(ubc1)
// [62] *((const nomodify byte*) SCREEN+(byte) 1) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_BYTE
sta SCREEN+1
// SCREEN[idx++] = typeid(ubv1)
// [63] *((const nomodify byte*) SCREEN+(byte) 2) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
sta SCREEN+2
// SCREEN[idx++] = typeid(120+130)
// [64] *((const nomodify byte*) SCREEN+(byte) 3) ← (byte) 0 -- _deref_pbuc1=vbuc2
lda #0
sta SCREEN+3
// SCREEN[idx++] = typeid(ubc1+250)
// [65] *((const nomodify byte*) SCREEN+(byte) 4) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
lda #TYPEID_BYTE
sta SCREEN+4
// SCREEN[idx++] = typeid(250+ubc1)
// [66] *((const nomodify byte*) SCREEN+(byte) 5) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
sta SCREEN+5
// SCREEN[idx++] = typeid(ubv1+250)
// [67] *((const nomodify byte*) SCREEN+(byte) 6) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
sta SCREEN+6
// SCREEN[idx++] = typeid(250+ubv1)
// [68] *((const nomodify byte*) SCREEN+(byte) 7) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
sta SCREEN+7
// SCREEN[idx++] = typeid(ubv1+ubc1)
// [69] *((const nomodify byte*) SCREEN+(byte) 8) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
sta SCREEN+8
// SCREEN[idx++] = typeid(ubc1+ubv1)
// [70] *((const nomodify byte*) SCREEN+(byte) 9) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
sta SCREEN+9
// SCREEN[idx++] = typeid(ubv1+ubv1)
// [71] *((const nomodify byte*) SCREEN+(byte) $a) ← (const byte) TYPEID_BYTE -- _deref_pbuc1=vbuc2
sta SCREEN+$a
// testUnsigned::@return
// }
// [72] return
rts
}
// File Data
Reference in New Issue View Git Blame Copy Permalink