6502/kickc
1
0
Fork 0
mirror of https://gitlab.com/camelot/kickc.git synced 2025-04-03 23:31:52 +00:00
Code Issues Projects Releases Wiki Activity

Added WORD0/1 and fragments. #221

Browse Source
This commit is contained in:
jespergravgaard 2021-04-06 00:18:49 +02:00
parent 510935eee7
commit 6fe60c6ad5
34 changed files with 1971 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/main/fragment/cache/fragment-cache-csg65ce02.asm vendored
View File

@ -1,4 +1,4 @@
//KICKC FRAGMENT CACHE e05113a8a e05115a22
//KICKC FRAGMENT CACHE 108dd16dc1 108dd18d7f
//FRAGMENT vbuz1=vbuc1
lda #{c1}
sta {z1}

2
src/main/fragment/cache/fragment-cache-mega45gs02.asm vendored
View File

@ -1,4 +1,4 @@
//KICKC FRAGMENT CACHE e05113a8a e05115a22
//KICKC FRAGMENT CACHE 108dd16dc1 108dd18d7f
//FRAGMENT _deref_pbuc1=vbuc2
lda #{c2}
sta {c1}

2
src/main/fragment/cache/fragment-cache-mos6502.asm vendored
View File

@ -1,4 +1,4 @@
//KICKC FRAGMENT CACHE e05113a8a e05115a22
//KICKC FRAGMENT CACHE 108dd16dc1 108dd18d7f
//FRAGMENT vbuz1=vbuc1
lda #{c1}
sta {z1}

141
src/main/fragment/cache/fragment-cache-mos6502x.asm vendored
View File

@ -1,52 +1,4 @@
//KICKC FRAGMENT CACHE e05113a8a e05115a22
//FRAGMENT vduz1=vduc1
lda #<{c1}
sta {z1}
lda #>{c1}
sta {z1}+1
lda #<{c1}>>$10
sta {z1}+2
lda #>{c1}>>$10
sta {z1}+3
//FRAGMENT vdsz1=vdsc1
lda #<{c1}
sta {z1}
lda #>{c1}
sta {z1}+1
lda #<{c1}>>$10
sta {z1}+2
lda #>{c1}>>$10
sta {z1}+3
//FRAGMENT _deref_pbuc1=vbuc2
lda #{c2}
sta {c1}
//FRAGMENT vbuz1=_byte3_vduz2
lda {z2}+3
sta {z1}
//FRAGMENT _deref_pbuc1=vbuz1
lda {z1}
sta {c1}
//FRAGMENT vbuz1=_byte3_vdsz2
lda {z2}+3
sta {z1}
//FRAGMENT vbuaa=_byte3_vduz1
lda {z1}+3
//FRAGMENT vbuxx=_byte3_vduz1
ldx {z1}+3
//FRAGMENT _deref_pbuc1=vbuaa
sta {c1}
//FRAGMENT vbuaa=_byte3_vdsz1
lda {z1}+3
//FRAGMENT vbuxx=_byte3_vdsz1
ldx {z1}+3
//FRAGMENT _deref_pbuc1=vbuxx
stx {c1}
//FRAGMENT vbuyy=_byte3_vduz1
ldy {z1}+3
//FRAGMENT _deref_pbuc1=vbuyy
sty {c1}
//FRAGMENT vbuyy=_byte3_vdsz1
ldy {z1}+3
//KICKC FRAGMENT CACHE 108dd16dc1 108dd18d7f
//FRAGMENT vbuz1=vbuc1
lda #{c1}
sta {z1}
@ -319,6 +271,9 @@ bcc {la1}
lda #{c2}
ldy {z1}
sta {c1},y
//FRAGMENT _deref_pbuc1=vbuc2
lda #{c2}
sta {c1}
//FRAGMENT vbuz1=vbuz1_plus_2
lda {z1}
clc
@ -1574,6 +1529,15 @@ sta {z1}+1
lda #0
sta {z1}+2
sta {z1}+3
//FRAGMENT vduz1=vduc1
lda #<{c1}
sta {z1}
lda #>{c1}
sta {z1}+1
lda #<{c1}>>$10
sta {z1}+2
lda #>{c1}>>$10
sta {z1}+3
//FRAGMENT vwuz1_neq_0_then_la1
lda {z1}
ora {z1}+1
@ -1731,6 +1695,9 @@ ldy {c1}+1
sty $ff
ldy #0
sta ($fe),y
//FRAGMENT _deref_pbuc1=vbuz1
lda {z1}
sta {c1}
//FRAGMENT _deref_qbuc1=pbuz1
lda {z1}
sta {c1}
@ -2079,6 +2046,8 @@ lda {c1}+2,y
sta {z1}+2
lda {c1}+3,y
sta {z1}+3
//FRAGMENT _deref_pbuc1=vbuaa
sta {c1}
//FRAGMENT vbuaa=vbuz1_bxor_vbuc1
lda #{c1}
eor {z1}
@ -2143,6 +2112,10 @@ ldy {c1}+1
sty $ff
ldy #0
sta ($fe),y
//FRAGMENT _deref_pbuc1=vbuxx
stx {c1}
//FRAGMENT _deref_pbuc1=vbuyy
sty {c1}
//FRAGMENT 0_neq_vbuyy_then_la1
cpy #0
bne {la1}
@ -4603,6 +4576,11 @@ lda ({z1}),y
sta {z1}+1
pla
sta {z1}
//FRAGMENT pprz1=pprz2
lda {z2}
sta {z1}
lda {z2}+1
sta {z1}+1
//FRAGMENT pprz1=qprc1_derefidx_vbuz2
ldy {z2}
lda {c1},y
@ -8079,6 +8057,15 @@ bcc {la1}
!:
//FRAGMENT vbuz1=vbuz1_rol_1
asl {z1}
//FRAGMENT vdsz1=vdsc1
lda #<{c1}
sta {z1}
lda #>{c1}
sta {z1}+1
lda #<{c1}>>$10
sta {z1}+2
lda #>{c1}>>$10
sta {z1}+3
//FRAGMENT vbuz1=_byte0_vbuz2
lda {z2}
sta {z1}
@ -8205,6 +8192,24 @@ ldx {z1}+2
ldy {z1}+2
//FRAGMENT vbuyy=_byte2_vdsz1
ldy {z1}+2
//FRAGMENT vbuz1=_byte3_vduz2
lda {z2}+3
sta {z1}
//FRAGMENT vbuz1=_byte3_vdsz2
lda {z2}+3
sta {z1}
//FRAGMENT vbuaa=_byte3_vduz1
lda {z1}+3
//FRAGMENT vbuxx=_byte3_vduz1
ldx {z1}+3
//FRAGMENT vbuaa=_byte3_vdsz1
lda {z1}+3
//FRAGMENT vbuxx=_byte3_vdsz1
ldx {z1}+3
//FRAGMENT vbuyy=_byte3_vduz1
ldy {z1}+3
//FRAGMENT vbuyy=_byte3_vdsz1
ldy {z1}+3
//FRAGMENT pbuc1_derefidx_vbuz1_eq_vbuc2_then_la1
ldy {z1}
lda {c1},y
@ -8232,6 +8237,44 @@ inc {c1},x
tya
tax
inc {c1},x
//FRAGMENT vwuz1=_word0_vbuz2
lda {z2}
sta {z1}
lda #0
sta {z1}+1
//FRAGMENT vwuz1=_word0_vbsz2
lda {z2}
sta {z1}
ora #$7f
bmi !+
lda #0
!:
sta {z1}+1
//FRAGMENT vwuz1=_word0_vwuz2
lda {z2}
sta {z1}
lda {z2}+1
sta {z1}+1
//FRAGMENT vwuz1=_word0_vwsz2
lda {z2}
sta {z1}
lda {z2}+1
sta {z1}+1
//FRAGMENT vwuz1=_word0_vduz2
lda {z2}
sta {z1}
lda {z2}+1
sta {z1}+1
//FRAGMENT vwuz1=_word0_vdsz2
lda {z2}
sta {z1}
lda {z2}+1
sta {z1}+1
//FRAGMENT vwuz1=_word0_pbuz2
lda {z2}
sta {z1}
lda {z2}+1
sta {z1}+1
//FRAGMENT vduz1=vduc1_plus_vbuz2
lda {z2}
clc

2
src/main/fragment/cache/fragment-cache-rom6502x.asm vendored
View File

@ -1,4 +1,4 @@
//KICKC FRAGMENT CACHE e05113a8a e05115a22
//KICKC FRAGMENT CACHE 108dd16dc1 108dd18d7f
//FRAGMENT _deref_pbuc1=_inc__deref_pbuc1
inc {c1}
//FRAGMENT isr_hardware_all_entry

2
src/main/fragment/cache/fragment-cache-wdc65c02.asm vendored
View File

@ -1,4 +1,4 @@
//KICKC FRAGMENT CACHE e05113a8a e05115a22
//KICKC FRAGMENT CACHE 108dd16dc1 108dd18d7f
//FRAGMENT vbuz1=vbuc1
lda #{c1}
sta {z1}

0
src/main/fragment/mos6502-common/vwum1=_word0_pvom1.asm Normal file
View File

4
src/main/fragment/mos6502-common/vwum1=_word0_pvom2.asm Normal file
View File

@ -0,0 +1,4 @@
lda {m2}
sta {m1}
lda {m2}+1
sta {m1}+1

6
src/main/fragment/mos6502-common/vwum1=_word0_vbsaa.asm Normal file
View File

@ -0,0 +1,6 @@
sta {m1}
ora #$7f
bmi !+
lda #0
!:
sta {m1}+1

3
src/main/fragment/mos6502-common/vwum1=_word0_vbuaa.asm Normal file
View File

@ -0,0 +1,3 @@
sta {m1}
lda #0
sta {m1}+1

4
src/main/fragment/mos6502-common/vwum1=_word0_vdsm2.asm Normal file
View File

@ -0,0 +1,4 @@
lda {m2}
sta {m1}
lda {m2}+1
sta {m1}+1

4
src/main/fragment/mos6502-common/vwum1=_word0_vdum2.asm Normal file
View File

@ -0,0 +1,4 @@
lda {m2}
sta {m1}
lda {m2}+1
sta {m1}+1

4
src/main/fragment/mos6502-common/vwum1=_word0_vwsm2.asm Normal file
View File

@ -0,0 +1,4 @@
lda {m2}
sta {m1}
lda {m2}+1
sta {m1}+1

4
src/main/fragment/mos6502-common/vwum1=_word0_vwum2.asm Normal file
View File

@ -0,0 +1,4 @@
lda {m2}
sta {m1}
lda {m2}+1
sta {m1}+1

4
src/main/fragment/mos6502-common/vwum1=_word1_vdsm2.asm Normal file
View File

@ -0,0 +1,4 @@
lda {m2}+2
sta {m1}
lda {m2}+3
sta {m1}+1

4
src/main/fragment/mos6502-common/vwum1=_word1_vdum2.asm Normal file
View File

@ -0,0 +1,4 @@
lda {m2}+2
sta {m1}
lda {m2}+3
sta {m1}+1

8
src/main/java/dk/camelot64/kickc/asm/AsmFormat.java
View File

@ -217,9 +217,13 @@ public class AsmFormat {
} else if(Operators.BYTE1.equals(operator)) {
return operator.getOperator() + "(" + getAsmConstant(program, operand, operator.getPrecedence(), codeScope) + ")";
} else if(Operators.BYTE2.equals(operator)) {
return "<" + "(" + getAsmConstant(program, new ConstantBinary(operand, Operators.SHIFT_RIGHT, new ConstantInteger((long) 16)), operator.getPrecedence(), codeScope) + ")";
return "<" + "(" + getAsmConstant(program, new ConstantBinary(operand, Operators.SHIFT_RIGHT, new ConstantInteger((long) 16)), outerPrecedence, codeScope) + ")";
} else if(Operators.BYTE3.equals(operator)) {
return ">" + "(" + getAsmConstant(program, new ConstantBinary(operand, Operators.SHIFT_RIGHT, new ConstantInteger((long) 16)), operator.getPrecedence(), codeScope) + ")";
return ">" + "(" + getAsmConstant(program, new ConstantBinary(operand, Operators.SHIFT_RIGHT, new ConstantInteger((long) 16)), outerPrecedence, codeScope) + ")";
} else if(Operators.WORD0.equals(operator)) {
return getAsmConstant(program, new ConstantBinary(operand, Operators.BOOL_AND, new ConstantInteger((long) 0xffff)), outerPrecedence, codeScope);
} else if(Operators.WORD1.equals(operator)) {
return getAsmConstant(program, new ConstantBinary(new ConstantBinary(operand, Operators.SHIFT_RIGHT, new ConstantInteger((long) 16)), Operators.BOOL_AND, new ConstantInteger((long) 0xffff)), outerPrecedence, codeScope);
} else if(Operators.INCREMENT.equals(operator)) {
return getAsmConstant(program, new ConstantBinary(operand, Operators.PLUS, new ConstantInteger((long) 1)), outerPrecedence, codeScope);
} else if(Operators.DECREMENT.equals(operator)) {

37
src/main/java/dk/camelot64/kickc/model/operators/OperatorGetWord0.java Normal file
View File

@ -0,0 +1,37 @@
package dk.camelot64.kickc.model.operators;
import dk.camelot64.kickc.model.ConstantNotLiteral;
import dk.camelot64.kickc.model.symbols.ProgramScope;
import dk.camelot64.kickc.model.types.SymbolType;
import dk.camelot64.kickc.model.values.ConstantInteger;
import dk.camelot64.kickc.model.values.ConstantLiteral;
import dk.camelot64.kickc.model.values.ConstantPointer;
import dk.camelot64.kickc.model.values.ConstantString;
/** Unary get word 0 operator word0(x) */
public class OperatorGetWord0 extends OperatorUnary {
public OperatorGetWord0(int precedence) {
super("_word0_", "_word0_", precedence);
}
@Override
public ConstantLiteral calculateLiteral(ConstantLiteral operand, ProgramScope scope) {
if(operand instanceof ConstantInteger) {
ConstantInteger operandInt = (ConstantInteger) operand;
return new ConstantInteger(operandInt.getInteger() & 0xffff, SymbolType.WORD);
} else if(operand instanceof ConstantPointer) {
return new ConstantInteger(((ConstantPointer) operand).getLocation() & 0xffff, SymbolType.WORD);
} else if(operand instanceof ConstantString) {
throw ConstantNotLiteral.getException();
}
throw ConstantNotLiteral.getException();
}
@Override
public SymbolType inferType(SymbolType operandType) {
return SymbolType.WORD;
}
}

37
src/main/java/dk/camelot64/kickc/model/operators/OperatorGetWord1.java Normal file
View File

@ -0,0 +1,37 @@
package dk.camelot64.kickc.model.operators;
import dk.camelot64.kickc.model.ConstantNotLiteral;
import dk.camelot64.kickc.model.symbols.ProgramScope;
import dk.camelot64.kickc.model.types.SymbolType;
import dk.camelot64.kickc.model.values.ConstantInteger;
import dk.camelot64.kickc.model.values.ConstantLiteral;
import dk.camelot64.kickc.model.values.ConstantPointer;
import dk.camelot64.kickc.model.values.ConstantString;
/** Unary get word 0 operator word0(x) */
public class OperatorGetWord1 extends OperatorUnary {
public OperatorGetWord1(int precedence) {
super("_word1_", "_word1_", precedence);
}
@Override
public ConstantLiteral calculateLiteral(ConstantLiteral operand, ProgramScope scope) {
if(operand instanceof ConstantInteger) {
ConstantInteger operandInt = (ConstantInteger) operand;
return new ConstantInteger((operandInt.getInteger()>>16) & 0xffff, SymbolType.WORD);
} else if(operand instanceof ConstantPointer) {
return new ConstantInteger((((ConstantPointer) operand).getLocation()>>16) & 0xffff, SymbolType.WORD);
} else if(operand instanceof ConstantString) {
throw ConstantNotLiteral.getException();
}
throw ConstantNotLiteral.getException();
}
@Override
public SymbolType inferType(SymbolType operandType) {
return SymbolType.WORD;
}
}

30
src/main/java/dk/camelot64/kickc/model/operators/Operators.java
View File

@ -38,12 +38,6 @@ public class Operators {
public static final OperatorBinary MINUS = new OperatorMinus(4);
public static final OperatorBinary SHIFT_LEFT = new OperatorShiftLeft(5);
public static final OperatorBinary SHIFT_RIGHT = new OperatorShiftRight(5);
public static final OperatorUnary LOWBYTE = new OperatorGetLow(14);
public static final OperatorUnary HIBYTE = new OperatorGetHigh(14);
public static final OperatorUnary BYTE0 = new OperatorGetByte0(14);
public static final OperatorUnary BYTE1 = new OperatorGetByte1(14);
public static final OperatorUnary BYTE2 = new OperatorGetByte2(14);
public static final OperatorUnary BYTE3 = new OperatorGetByte3(14);
public static final OperatorBinary LT = new OperatorLessThan(7);
public static final OperatorBinary LE = new OperatorLessThanEqual(7);
public static final OperatorBinary GT = new OperatorGreaterThan(7);
@ -56,6 +50,14 @@ public class Operators {
public static final OperatorBinary LOGIC_AND = new OperatorLogicAnd(12);
public static final OperatorBinary LOGIC_OR = new OperatorLogicOr(13);
public static final OperatorBinary ASSIGNMENT = new OperatorAssignment(14);
public static final OperatorUnary LOWBYTE = new OperatorGetLow(14);
public static final OperatorUnary HIBYTE = new OperatorGetHigh(14);
public static final OperatorUnary BYTE0 = new OperatorGetByte0(14);
public static final OperatorUnary BYTE1 = new OperatorGetByte1(14);
public static final OperatorUnary BYTE2 = new OperatorGetByte2(14);
public static final OperatorUnary BYTE3 = new OperatorGetByte3(14);
public static final OperatorUnary WORD0 = new OperatorGetWord0(14);
public static final OperatorUnary WORD1 = new OperatorGetWord1(14);
public static Operator getBinary(String op) {
switch(op) {
@ -136,14 +138,16 @@ public class Operators {
return LOWBYTE;
case ">":
return HIBYTE;
case "b0":
case "byte0":
return BYTE0;
//case "b1":
// return BYTE1;
//case "b2":
// return BYTE2;
//case "b3":
// return BYTE3;
case "byte1":
return BYTE1;
case "byte2":
return BYTE2;
case "byte3":
return BYTE3;
case "word0":
return WORD0;
case "&":
return ADDRESS_OF;
default:

4
src/main/java/dk/camelot64/kickc/passes/Pass0GenerateStatementSequence.java
View File

@ -2392,6 +2392,10 @@ public class Pass0GenerateStatementSequence extends KickCParserBaseVisitor<Objec
result = addExprUnary(ctx, Operators.BYTE2, parameters.get(0));
} else if(Pass1ByteXIntrinsicRewrite.INTRINSIC_BYTE3_NAME.equals(procedureName) && parameters.size()==1) {
result = addExprUnary(ctx, Operators.BYTE3, parameters.get(0));
} else if(Pass1ByteXIntrinsicRewrite.INTRINSIC_WORD0_NAME.equals(procedureName) && parameters.size()==1) {
result = addExprUnary(ctx, Operators.WORD0, parameters.get(0));
} else if(Pass1ByteXIntrinsicRewrite.INTRINSIC_WORD1_NAME.equals(procedureName) && parameters.size()==1) {
result = addExprUnary(ctx, Operators.WORD1, parameters.get(0));
} else {
// A normal named call
result = addIntermediateVar().getRef();

12
src/main/java/dk/camelot64/kickc/passes/Pass1ByteXIntrinsicRewrite.java
View File

@ -26,6 +26,10 @@ public class Pass1ByteXIntrinsicRewrite extends Pass2SsaOptimization {
public static final String INTRINSIC_BYTE2_NAME = "BYTE2";
/** The byte3 procedure name. */
public static final String INTRINSIC_BYTE3_NAME = "BYTE3";
/** The word0 procedure name. */
public static final String INTRINSIC_WORD0_NAME = "WORD0";
/** The word1 procedure name. */
public static final String INTRINSIC_WORD1_NAME = "WORD1";
public Pass1ByteXIntrinsicRewrite(Program program) {
super(program);
@ -48,6 +52,10 @@ public class Pass1ByteXIntrinsicRewrite extends Pass2SsaOptimization {
generateUnaryOperator(stmtIt, call, parameters, Operators.BYTE2);
} else if(INTRINSIC_BYTE3_NAME.equals(call.getProcedureName())) {
generateUnaryOperator(stmtIt, call, parameters, Operators.BYTE3);
} else if(INTRINSIC_WORD0_NAME.equals(call.getProcedureName())) {
generateUnaryOperator(stmtIt, call, parameters, Operators.WORD0);
} else if(INTRINSIC_WORD1_NAME.equals(call.getProcedureName())) {
generateUnaryOperator(stmtIt, call, parameters, Operators.WORD1);
}
}
}
@ -56,7 +64,7 @@ public class Pass1ByteXIntrinsicRewrite extends Pass2SsaOptimization {
}
/**
* Generate an unary operator expression for the BYTEX()
* Generate an unary operator expression for the BYTEX()/WORDX()
*/
private void generateUnaryOperator(ListIterator<Statement> stmtIt, StatementCall call, List<RValue> parameters, OperatorUnary operator) {
if(parameters.size()!=1) {
@ -64,7 +72,7 @@ public class Pass1ByteXIntrinsicRewrite extends Pass2SsaOptimization {
}
// Remove the call
stmtIt.remove();
// Add the unary byte0 operator
// Add the unary operator
stmtIt.add(new StatementAssignment(call.getlValue(), operator, parameters.get(0), call.isInitialAssignment(), call.getSource(), call.getComments()));
}

6
src/main/java/dk/camelot64/kickc/passes/Pass2ConstantRValueConsolidation.java
View File

@ -96,6 +96,12 @@ public class Pass2ConstantRValueConsolidation extends Pass2SsaOptimization {
return new ConstantInteger(0l, SymbolType.BYTE);
else if(rVal2Type instanceof SymbolTypePointer)
return new ConstantInteger(0l, SymbolType.BYTE);
} else if(Operators.WORD1.equals(assignment.getOperator()) && assignment.getrValue1() == null) {
final SymbolType rVal2Type = SymbolTypeInference.inferType(getScope(), assignment.getrValue2());
if(SymbolType.isInteger(rVal2Type) && rVal2Type.getSizeBytes() < 3)
return new ConstantInteger(0l, SymbolType.WORD);
else if(rVal2Type instanceof SymbolTypePointer)
return new ConstantInteger(0l, SymbolType.WORD);
} else if(Operators.ADDRESS_OF.equals(assignment.getOperator()) && assignment.getrValue1() == null) {
// Constant address-of variable
if(assignment.getrValue2() instanceof SymbolRef) {

10
src/test/java/dk/camelot64/kickc/test/TestPrograms.java
View File

@ -49,6 +49,16 @@ public class TestPrograms {
compileAndCompare("operator-byte0-initializer.c");
}
@Test
public void testOperatorWord1() throws IOException, URISyntaxException {
compileAndCompare("operator-word1.c");
}
@Test
public void testOperatorWord0() throws IOException, URISyntaxException {
compileAndCompare("operator-word0.c");
}
@Test
public void testOperatorByte3() throws IOException, URISyntaxException {
compileAndCompare("operator-byte3.c");

23
src/test/kc/operator-word0.c Normal file
View File

@ -0,0 +1,23 @@
// Test operator WORD0()
void main() {
volatile unsigned char bu = 7;
volatile signed char bs = 7;
volatile unsigned int wu = 20000;
volatile signed int ws = -177;
volatile unsigned long du = 2000000;
volatile signed long ds = -3777777;
char * volatile ptr = 0x0000;
unsigned int * const SCREEN = 0x0400;
char i = 0;
SCREEN[i++] = WORD0(17);
SCREEN[i++] = WORD0(377);
SCREEN[i++] = WORD0(bu);
SCREEN[i++] = WORD0(bs);
SCREEN[i++] = WORD0(wu);
SCREEN[i++] = WORD0(ws);
SCREEN[i++] = WORD0(du);
SCREEN[i++] = WORD0(ds);
SCREEN[i++] = WORD0(ptr);
}

23
src/test/kc/operator-word1.c Normal file
View File

@ -0,0 +1,23 @@
// Test operator WORD1()
void main() {
volatile unsigned char bu = 7;
volatile signed char bs = 7;
volatile unsigned int wu = 20000;
volatile signed int ws = -177;
volatile unsigned long du = 2000000;
volatile signed long ds = -3777777;
char * volatile ptr = 0x0000;
unsigned int * const SCREEN = 0x0400;
char i = 0;
SCREEN[i++] = WORD1(17);
SCREEN[i++] = WORD1(377);
SCREEN[i++] = WORD1(bu);
SCREEN[i++] = WORD1(bs);
SCREEN[i++] = WORD1(wu);
SCREEN[i++] = WORD1(ws);
SCREEN[i++] = WORD1(du);
SCREEN[i++] = WORD1(ds);
SCREEN[i++] = WORD1(ptr);
}

150
src/test/ref/operator-word0.asm Normal file
View File

@ -0,0 +1,150 @@
// Test operator WORD0()
// Commodore 64 PRG executable file
.file [name="operator-word0.prg", type="prg", segments="Program"]
.segmentdef Program [segments="Basic, Code, Data"]
.segmentdef Basic [start=$0801]
.segmentdef Code [start=$80d]
.segmentdef Data [startAfter="Code"]
.segment Basic
:BasicUpstart(main)
.const SIZEOF_WORD = 2
.segment Code
main: {
.label SCREEN = $400
.label bu = 2
.label bs = 3
.label wu = 4
.label ws = 6
.label du = 8
.label ds = $c
.label ptr = $10
.label __0 = $12
.label __1 = $14
.label __2 = $16
.label __3 = $18
.label __4 = $1a
.label __5 = $1c
.label __6 = $1e
// bu = 7
lda #7
sta.z bu
// bs = 7
sta.z bs
// wu = 20000
lda #<$4e20
sta.z wu
lda #>$4e20
sta.z wu+1
// ws = -177
lda #<-$b1
sta.z ws
lda #>-$b1
sta.z ws+1
// du = 2000000
lda #<$1e8480
sta.z du
lda #>$1e8480
sta.z du+1
lda #<$1e8480>>$10
sta.z du+2
lda #>$1e8480>>$10
sta.z du+3
// ds = -3777777
lda #<-$39a4f1
sta.z ds
lda #>-$39a4f1
sta.z ds+1
lda #<-$39a4f1>>$10
sta.z ds+2
lda #>-$39a4f1>>$10
sta.z ds+3
// ptr = 0x0000
lda #<0
sta.z ptr
sta.z ptr+1
// SCREEN[i++] = WORD0(17)
lda #<$11&$ffff
sta SCREEN
lda #>$11&$ffff
sta SCREEN+1
// SCREEN[i++] = WORD0(377)
lda #<$179&$ffff
sta SCREEN+1*SIZEOF_WORD
lda #>$179&$ffff
sta SCREEN+1*SIZEOF_WORD+1
// WORD0(bu)
lda.z bu
sta.z __0
lda #0
sta.z __0+1
// SCREEN[i++] = WORD0(bu)
lda.z __0
sta SCREEN+2*SIZEOF_WORD
lda.z __0+1
sta SCREEN+2*SIZEOF_WORD+1
// WORD0(bs)
lda.z bs
sta.z __1
ora #$7f
bmi !+
lda #0
!:
sta.z __1+1
// SCREEN[i++] = WORD0(bs)
lda.z __1
sta SCREEN+3*SIZEOF_WORD
lda.z __1+1
sta SCREEN+3*SIZEOF_WORD+1
// WORD0(wu)
lda.z wu
sta.z __2
lda.z wu+1
sta.z __2+1
// SCREEN[i++] = WORD0(wu)
lda.z __2
sta SCREEN+4*SIZEOF_WORD
lda.z __2+1
sta SCREEN+4*SIZEOF_WORD+1
// WORD0(ws)
lda.z ws
sta.z __3
lda.z ws+1
sta.z __3+1
// SCREEN[i++] = WORD0(ws)
lda.z __3
sta SCREEN+5*SIZEOF_WORD
lda.z __3+1
sta SCREEN+5*SIZEOF_WORD+1
// WORD0(du)
lda.z du
sta.z __4
lda.z du+1
sta.z __4+1
// SCREEN[i++] = WORD0(du)
lda.z __4
sta SCREEN+6*SIZEOF_WORD
lda.z __4+1
sta SCREEN+6*SIZEOF_WORD+1
// WORD0(ds)
lda.z ds
sta.z __5
lda.z ds+1
sta.z __5+1
// SCREEN[i++] = WORD0(ds)
lda.z __5
sta SCREEN+7*SIZEOF_WORD
lda.z __5+1
sta SCREEN+7*SIZEOF_WORD+1
// WORD0(ptr)
lda.z ptr
sta.z __6
lda.z ptr+1
sta.z __6+1
// SCREEN[i++] = WORD0(ptr)
lda.z __6
sta SCREEN+8*SIZEOF_WORD
lda.z __6+1
sta SCREEN+8*SIZEOF_WORD+1
// }
rts
}

30
src/test/ref/operator-word0.cfg Normal file
View File

@ -0,0 +1,30 @@
void main()
main: scope:[main] from
[0] main::bu = 7
[1] main::bs = 7
[2] main::wu = $4e20
[3] main::ws = -$b1
[4] main::du = $1e8480
[5] main::ds = -$39a4f1
[6] main::ptr = (byte*) 0
[7] *main::SCREEN = _word0_$11
[8] *(main::SCREEN+1*SIZEOF_WORD) = _word0_$179
[9] main::$0 = _word0_ main::bu
[10] *(main::SCREEN+2*SIZEOF_WORD) = main::$0
[11] main::$1 = _word0_ main::bs
[12] *(main::SCREEN+3*SIZEOF_WORD) = main::$1
[13] main::$2 = _word0_ main::wu
[14] *(main::SCREEN+4*SIZEOF_WORD) = main::$2
[15] main::$3 = _word0_ main::ws
[16] *(main::SCREEN+5*SIZEOF_WORD) = main::$3
[17] main::$4 = _word0_ main::du
[18] *(main::SCREEN+6*SIZEOF_WORD) = main::$4
[19] main::$5 = _word0_ main::ds
[20] *(main::SCREEN+7*SIZEOF_WORD) = main::$5
[21] main::$6 = _word0_ main::ptr
[22] *(main::SCREEN+8*SIZEOF_WORD) = main::$6
to:main::@return
main::@return: scope:[main] from main
[23] return
to:@return

769
src/test/ref/operator-word0.log Normal file
View File

@ -0,0 +1,769 @@
CONTROL FLOW GRAPH SSA
void main()
main: scope:[main] from __start
main::bu = 7
main::bs = 7
main::wu = $4e20
main::ws = -$b1
main::du = $1e8480
main::ds = -$39a4f1
main::ptr = (byte*)0
main::i#0 = 0
main::$7 = main::i#0 * SIZEOF_WORD
main::SCREEN[main::$7] = _word0_$11
main::i#1 = ++ main::i#0
main::$8 = main::i#1 * SIZEOF_WORD
main::SCREEN[main::$8] = _word0_$179
main::i#2 = ++ main::i#1
main::$0 = _word0_ main::bu
main::$9 = main::i#2 * SIZEOF_WORD
main::SCREEN[main::$9] = main::$0
main::i#3 = ++ main::i#2
main::$1 = _word0_ main::bs
main::$10 = main::i#3 * SIZEOF_WORD
main::SCREEN[main::$10] = main::$1
main::i#4 = ++ main::i#3
main::$2 = _word0_ main::wu
main::$11 = main::i#4 * SIZEOF_WORD
main::SCREEN[main::$11] = main::$2
main::i#5 = ++ main::i#4
main::$3 = _word0_ main::ws
main::$12 = main::i#5 * SIZEOF_WORD
main::SCREEN[main::$12] = main::$3
main::i#6 = ++ main::i#5
main::$4 = _word0_ main::du
main::$13 = main::i#6 * SIZEOF_WORD
main::SCREEN[main::$13] = main::$4
main::i#7 = ++ main::i#6
main::$5 = _word0_ main::ds
main::$14 = main::i#7 * SIZEOF_WORD
main::SCREEN[main::$14] = main::$5
main::i#8 = ++ main::i#7
main::$6 = _word0_ main::ptr
main::$15 = main::i#8 * SIZEOF_WORD
main::SCREEN[main::$15] = main::$6
main::i#9 = ++ main::i#8
to:main::@return
main::@return: scope:[main] from main
return
to:@return
void __start()
__start: scope:[__start] from
call main
to:__start::@1
__start::@1: scope:[__start] from __start
to:__start::@return
__start::@return: scope:[__start] from __start::@1
return
to:@return
SYMBOL TABLE SSA
const byte SIZEOF_WORD = 2
void __start()
void main()
word~ main::$0
word~ main::$1
byte~ main::$10
byte~ main::$11
byte~ main::$12
byte~ main::$13
byte~ main::$14
byte~ main::$15
word~ main::$2
word~ main::$3
word~ main::$4
word~ main::$5
word~ main::$6
byte~ main::$7
byte~ main::$8
byte~ main::$9
const nomodify word* main::SCREEN = (word*)$400
volatile signed byte main::bs loadstore
volatile byte main::bu loadstore
volatile signed dword main::ds loadstore
volatile dword main::du loadstore
byte main::i
byte main::i#0
byte main::i#1
byte main::i#2
byte main::i#3
byte main::i#4
byte main::i#5
byte main::i#6
byte main::i#7
byte main::i#8
byte main::i#9
volatile byte* main::ptr loadstore
volatile signed word main::ws loadstore
volatile word main::wu loadstore
Simplifying constant pointer cast (word*) 1024
Simplifying constant pointer cast (byte*) 0
Successful SSA optimization PassNCastSimplification
Constant main::i#0 = 0
Successful SSA optimization Pass2ConstantIdentification
Eliminating unused variable main::i#9 and assignment [40] main::i#9 = ++ main::i#8
Successful SSA optimization PassNEliminateUnusedVars
Removing unused procedure __start
Removing unused procedure block __start
Removing unused procedure block __start::@1
Removing unused procedure block __start::@return
Successful SSA optimization PassNEliminateEmptyStart
Constant right-side identified [7] main::$7 = main::i#0 * SIZEOF_WORD
Constant right-side identified [9] main::i#1 = ++ main::i#0
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant main::$7 = main::i#0*SIZEOF_WORD
Constant main::i#1 = ++main::i#0
Successful SSA optimization Pass2ConstantIdentification
Simplifying constant evaluating to zero main::i#0*SIZEOF_WORD in
Successful SSA optimization PassNSimplifyConstantZero
Simplifying expression containing zero main::SCREEN in [8] main::SCREEN[main::$7] = _word0_$11
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused constant main::$7
Successful SSA optimization PassNEliminateUnusedVars
Constant right-side identified [8] main::$8 = main::i#1 * SIZEOF_WORD
Constant right-side identified [10] main::i#2 = ++ main::i#1
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant main::$8 = main::i#1*SIZEOF_WORD
Constant main::i#2 = ++main::i#1
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [10] main::$9 = main::i#2 * SIZEOF_WORD
Constant right-side identified [12] main::i#3 = ++ main::i#2
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant main::$9 = main::i#2*SIZEOF_WORD
Constant main::i#3 = ++main::i#2
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [12] main::$10 = main::i#3 * SIZEOF_WORD
Constant right-side identified [14] main::i#4 = ++ main::i#3
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant main::$10 = main::i#3*SIZEOF_WORD
Constant main::i#4 = ++main::i#3
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [14] main::$11 = main::i#4 * SIZEOF_WORD
Constant right-side identified [16] main::i#5 = ++ main::i#4
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant main::$11 = main::i#4*SIZEOF_WORD
Constant main::i#5 = ++main::i#4
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [16] main::$12 = main::i#5 * SIZEOF_WORD
Constant right-side identified [18] main::i#6 = ++ main::i#5
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant main::$12 = main::i#5*SIZEOF_WORD
Constant main::i#6 = ++main::i#5
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [18] main::$13 = main::i#6 * SIZEOF_WORD
Constant right-side identified [20] main::i#7 = ++ main::i#6
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant main::$13 = main::i#6*SIZEOF_WORD
Constant main::i#7 = ++main::i#6
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [20] main::$14 = main::i#7 * SIZEOF_WORD
Constant right-side identified [22] main::i#8 = ++ main::i#7
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant main::$14 = main::i#7*SIZEOF_WORD
Constant main::i#8 = ++main::i#7
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [22] main::$15 = main::i#8 * SIZEOF_WORD
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant main::$15 = main::i#8*SIZEOF_WORD
Successful SSA optimization Pass2ConstantIdentification
Inlining constant with different constant siblings main::i#0
Inlining constant with different constant siblings main::i#1
Inlining constant with different constant siblings main::i#2
Inlining constant with different constant siblings main::i#3
Inlining constant with different constant siblings main::i#4
Inlining constant with different constant siblings main::i#5
Inlining constant with different constant siblings main::i#6
Inlining constant with different constant siblings main::i#7
Inlining constant with different constant siblings main::i#8
Constant inlined main::i#8 = ++++++++++++++++0
Constant inlined main::i#7 = ++++++++++++++0
Constant inlined main::i#4 = ++++++++0
Constant inlined main::i#3 = ++++++0
Constant inlined main::i#6 = ++++++++++++0
Constant inlined main::i#5 = ++++++++++0
Constant inlined main::$12 = ++++++++++0*SIZEOF_WORD
Constant inlined main::$13 = ++++++++++++0*SIZEOF_WORD
Constant inlined main::$14 = ++++++++++++++0*SIZEOF_WORD
Constant inlined main::$15 = ++++++++++++++++0*SIZEOF_WORD
Constant inlined main::$10 = ++++++0*SIZEOF_WORD
Constant inlined main::$11 = ++++++++0*SIZEOF_WORD
Constant inlined main::i#0 = 0
Constant inlined main::i#2 = ++++0
Constant inlined main::i#1 = ++0
Constant inlined main::$9 = ++++0*SIZEOF_WORD
Constant inlined main::$8 = ++0*SIZEOF_WORD
Successful SSA optimization Pass2ConstantInlining
Consolidated array index constant in *(main::SCREEN+++0*SIZEOF_WORD)
Consolidated array index constant in *(main::SCREEN+++++0*SIZEOF_WORD)
Consolidated array index constant in *(main::SCREEN+++++++0*SIZEOF_WORD)
Consolidated array index constant in *(main::SCREEN+++++++++0*SIZEOF_WORD)
Consolidated array index constant in *(main::SCREEN+++++++++++0*SIZEOF_WORD)
Consolidated array index constant in *(main::SCREEN+++++++++++++0*SIZEOF_WORD)
Consolidated array index constant in *(main::SCREEN+++++++++++++++0*SIZEOF_WORD)
Consolidated array index constant in *(main::SCREEN+++++++++++++++++0*SIZEOF_WORD)
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
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
Successful SSA optimization Pass2ConstantSimplification
Finalized unsigned number type (byte) $11
Finalized unsigned number type (word) $179
Successful SSA optimization PassNFinalizeNumberTypeConversions
CALL GRAPH
Created 0 initial phi equivalence classes
Coalesced down to 0 phi equivalence classes
FINAL CONTROL FLOW GRAPH
void main()
main: scope:[main] from
[0] main::bu = 7
[1] main::bs = 7
[2] main::wu = $4e20
[3] main::ws = -$b1
[4] main::du = $1e8480
[5] main::ds = -$39a4f1
[6] main::ptr = (byte*) 0
[7] *main::SCREEN = _word0_$11
[8] *(main::SCREEN+1*SIZEOF_WORD) = _word0_$179
[9] main::$0 = _word0_ main::bu
[10] *(main::SCREEN+2*SIZEOF_WORD) = main::$0
[11] main::$1 = _word0_ main::bs
[12] *(main::SCREEN+3*SIZEOF_WORD) = main::$1
[13] main::$2 = _word0_ main::wu
[14] *(main::SCREEN+4*SIZEOF_WORD) = main::$2
[15] main::$3 = _word0_ main::ws
[16] *(main::SCREEN+5*SIZEOF_WORD) = main::$3
[17] main::$4 = _word0_ main::du
[18] *(main::SCREEN+6*SIZEOF_WORD) = main::$4
[19] main::$5 = _word0_ main::ds
[20] *(main::SCREEN+7*SIZEOF_WORD) = main::$5
[21] main::$6 = _word0_ main::ptr
[22] *(main::SCREEN+8*SIZEOF_WORD) = main::$6
to:main::@return
main::@return: scope:[main] from main
[23] return
to:@return
VARIABLE REGISTER WEIGHTS
void main()
word~ main::$0 4.0
word~ main::$1 4.0
word~ main::$2 4.0
word~ main::$3 4.0
word~ main::$4 4.0
word~ main::$5 4.0
word~ main::$6 4.0
volatile signed byte main::bs loadstore 0.4
volatile byte main::bu loadstore 0.4444444444444444
volatile signed dword main::ds loadstore 0.2857142857142857
volatile dword main::du loadstore 0.3076923076923077
byte main::i
volatile byte* main::ptr loadstore 0.26666666666666666
volatile signed word main::ws loadstore 0.3333333333333333
volatile word main::wu loadstore 0.36363636363636365
Initial phi equivalence classes
Added variable main::bu to live range equivalence class [ main::bu ]
Added variable main::bs to live range equivalence class [ main::bs ]
Added variable main::wu to live range equivalence class [ main::wu ]
Added variable main::ws to live range equivalence class [ main::ws ]
Added variable main::du to live range equivalence class [ main::du ]
Added variable main::ds to live range equivalence class [ main::ds ]
Added variable main::ptr to live range equivalence class [ main::ptr ]
Added variable main::$0 to live range equivalence class [ main::$0 ]
Added variable main::$1 to live range equivalence class [ main::$1 ]
Added variable main::$2 to live range equivalence class [ main::$2 ]
Added variable main::$3 to live range equivalence class [ main::$3 ]
Added variable main::$4 to live range equivalence class [ main::$4 ]
Added variable main::$5 to live range equivalence class [ main::$5 ]
Added variable main::$6 to live range equivalence class [ main::$6 ]
Complete equivalence classes
[ main::bu ]
[ main::bs ]
[ main::wu ]
[ main::ws ]
[ main::du ]
[ main::ds ]
[ main::ptr ]
[ main::$0 ]
[ main::$1 ]
[ main::$2 ]
[ main::$3 ]
[ main::$4 ]
[ main::$5 ]
[ main::$6 ]
Allocated zp[1]:2 [ main::bu ]
Allocated zp[1]:3 [ main::bs ]
Allocated zp[2]:4 [ main::wu ]
Allocated zp[2]:6 [ main::ws ]
Allocated zp[4]:8 [ main::du ]
Allocated zp[4]:12 [ main::ds ]
Allocated zp[2]:16 [ main::ptr ]
Allocated zp[2]:18 [ main::$0 ]
Allocated zp[2]:20 [ main::$1 ]
Allocated zp[2]:22 [ main::$2 ]
Allocated zp[2]:24 [ main::$3 ]
Allocated zp[2]:26 [ main::$4 ]
Allocated zp[2]:28 [ main::$5 ]
Allocated zp[2]:30 [ main::$6 ]
REGISTER UPLIFT POTENTIAL REGISTERS
Statement [0] main::bu = 7 [ main::bu ] ( [ main::bu ] { } ) always clobbers reg byte a
Statement [1] main::bs = 7 [ main::bu main::bs ] ( [ main::bu main::bs ] { } ) always clobbers reg byte a
Statement [2] main::wu = $4e20 [ main::bu main::bs main::wu ] ( [ main::bu main::bs main::wu ] { } ) always clobbers reg byte a
Statement [3] main::ws = -$b1 [ main::bu main::bs main::wu main::ws ] ( [ main::bu main::bs main::wu main::ws ] { } ) always clobbers reg byte a
Statement [4] main::du = $1e8480 [ main::bu main::bs main::wu main::ws main::du ] ( [ main::bu main::bs main::wu main::ws main::du ] { } ) always clobbers reg byte a
Statement [5] main::ds = -$39a4f1 [ main::bu main::bs main::wu main::ws main::du main::ds ] ( [ main::bu main::bs main::wu main::ws main::du main::ds ] { } ) always clobbers reg byte a
Statement [6] main::ptr = (byte*) 0 [ main::bu main::bs main::wu main::ws main::du main::ds main::ptr ] ( [ main::bu main::bs main::wu main::ws main::du main::ds main::ptr ] { } ) always clobbers reg byte a
Statement [7] *main::SCREEN = _word0_$11 [ main::bu main::bs main::wu main::ws main::du main::ds main::ptr ] ( [ main::bu main::bs main::wu main::ws main::du main::ds main::ptr ] { } ) always clobbers reg byte a
Statement [8] *(main::SCREEN+1*SIZEOF_WORD) = _word0_$179 [ main::bu main::bs main::wu main::ws main::du main::ds main::ptr ] ( [ main::bu main::bs main::wu main::ws main::du main::ds main::ptr ] { } ) always clobbers reg byte a
Statement [9] main::$0 = _word0_ main::bu [ main::bs main::wu main::ws main::du main::ds main::ptr main::$0 ] ( [ main::bs main::wu main::ws main::du main::ds main::ptr main::$0 ] { } ) always clobbers reg byte a
Statement [10] *(main::SCREEN+2*SIZEOF_WORD) = main::$0 [ main::bs main::wu main::ws main::du main::ds main::ptr ] ( [ main::bs main::wu main::ws main::du main::ds main::ptr ] { } ) always clobbers reg byte a
Statement [11] main::$1 = _word0_ main::bs [ main::wu main::ws main::du main::ds main::ptr main::$1 ] ( [ main::wu main::ws main::du main::ds main::ptr main::$1 ] { } ) always clobbers reg byte a
Statement [12] *(main::SCREEN+3*SIZEOF_WORD) = main::$1 [ main::wu main::ws main::du main::ds main::ptr ] ( [ main::wu main::ws main::du main::ds main::ptr ] { } ) always clobbers reg byte a
Statement [13] main::$2 = _word0_ main::wu [ main::ws main::du main::ds main::ptr main::$2 ] ( [ main::ws main::du main::ds main::ptr main::$2 ] { } ) always clobbers reg byte a
Statement [14] *(main::SCREEN+4*SIZEOF_WORD) = main::$2 [ main::ws main::du main::ds main::ptr ] ( [ main::ws main::du main::ds main::ptr ] { } ) always clobbers reg byte a
Statement [15] main::$3 = _word0_ main::ws [ main::du main::ds main::ptr main::$3 ] ( [ main::du main::ds main::ptr main::$3 ] { } ) always clobbers reg byte a
Statement [16] *(main::SCREEN+5*SIZEOF_WORD) = main::$3 [ main::du main::ds main::ptr ] ( [ main::du main::ds main::ptr ] { } ) always clobbers reg byte a
Statement [17] main::$4 = _word0_ main::du [ main::ds main::ptr main::$4 ] ( [ main::ds main::ptr main::$4 ] { } ) always clobbers reg byte a
Statement [18] *(main::SCREEN+6*SIZEOF_WORD) = main::$4 [ main::ds main::ptr ] ( [ main::ds main::ptr ] { } ) always clobbers reg byte a
Statement [19] main::$5 = _word0_ main::ds [ main::ptr main::$5 ] ( [ main::ptr main::$5 ] { } ) always clobbers reg byte a
Statement [20] *(main::SCREEN+7*SIZEOF_WORD) = main::$5 [ main::ptr ] ( [ main::ptr ] { } ) always clobbers reg byte a
Statement [21] main::$6 = _word0_ main::ptr [ main::$6 ] ( [ main::$6 ] { } ) always clobbers reg byte a
Statement [22] *(main::SCREEN+8*SIZEOF_WORD) = main::$6 [ ] ( [ ] { } ) always clobbers reg byte a
Potential registers zp[1]:2 [ main::bu ] : zp[1]:2 ,
Potential registers zp[1]:3 [ main::bs ] : zp[1]:3 ,
Potential registers zp[2]:4 [ main::wu ] : zp[2]:4 ,
Potential registers zp[2]:6 [ main::ws ] : zp[2]:6 ,
Potential registers zp[4]:8 [ main::du ] : zp[4]:8 ,
Potential registers zp[4]:12 [ main::ds ] : zp[4]:12 ,
Potential registers zp[2]:16 [ main::ptr ] : zp[2]:16 ,
Potential registers zp[2]:18 [ main::$0 ] : zp[2]:18 ,
Potential registers zp[2]:20 [ main::$1 ] : zp[2]:20 ,
Potential registers zp[2]:22 [ main::$2 ] : zp[2]:22 ,
Potential registers zp[2]:24 [ main::$3 ] : zp[2]:24 ,
Potential registers zp[2]:26 [ main::$4 ] : zp[2]:26 ,
Potential registers zp[2]:28 [ main::$5 ] : zp[2]:28 ,
Potential registers zp[2]:30 [ main::$6 ] : zp[2]:30 ,
REGISTER UPLIFT SCOPES
Uplift Scope [main] 4: zp[2]:18 [ main::$0 ] 4: zp[2]:20 [ main::$1 ] 4: zp[2]:22 [ main::$2 ] 4: zp[2]:24 [ main::$3 ] 4: zp[2]:26 [ main::$4 ] 4: zp[2]:28 [ main::$5 ] 4: zp[2]:30 [ main::$6 ] 0.44: zp[1]:2 [ main::bu ] 0.4: zp[1]:3 [ main::bs ] 0.36: zp[2]:4 [ main::wu ] 0.33: zp[2]:6 [ main::ws ] 0.31: zp[4]:8 [ main::du ] 0.29: zp[4]:12 [ main::ds ] 0.27: zp[2]:16 [ main::ptr ]
Uplift Scope []
Uplifting [main] best 297 combination zp[2]:18 [ main::$0 ] zp[2]:20 [ main::$1 ] zp[2]:22 [ main::$2 ] zp[2]:24 [ main::$3 ] zp[2]:26 [ main::$4 ] zp[2]:28 [ main::$5 ] zp[2]:30 [ main::$6 ] zp[1]:2 [ main::bu ] zp[1]:3 [ main::bs ] zp[2]:4 [ main::wu ] zp[2]:6 [ main::ws ] zp[4]:8 [ main::du ] zp[4]:12 [ main::ds ] zp[2]:16 [ main::ptr ]
Uplifting [] best 297 combination
Attempting to uplift remaining variables inzp[1]:2 [ main::bu ]
Uplifting [main] best 297 combination zp[1]:2 [ main::bu ]
Attempting to uplift remaining variables inzp[1]:3 [ main::bs ]
Uplifting [main] best 297 combination zp[1]:3 [ main::bs ]
ASSEMBLER BEFORE OPTIMIZATION
// File Comments
// Test operator WORD0()
// Upstart
// Commodore 64 PRG executable file
.file [name="operator-word0.prg", type="prg", segments="Program"]
.segmentdef Program [segments="Basic, Code, Data"]
.segmentdef Basic [start=$0801]
.segmentdef Code [start=$80d]
.segmentdef Data [startAfter="Code"]
.segment Basic
:BasicUpstart(main)
// Global Constants & labels
.const SIZEOF_WORD = 2
.segment Code
// main
main: {
.label SCREEN = $400
.label bu = 2
.label bs = 3
.label wu = 4
.label ws = 6
.label du = 8
.label ds = $c
.label ptr = $10
.label __0 = $12
.label __1 = $14
.label __2 = $16
.label __3 = $18
.label __4 = $1a
.label __5 = $1c
.label __6 = $1e
// [0] main::bu = 7 -- vbuz1=vbuc1
lda #7
sta.z bu
// [1] main::bs = 7 -- vbsz1=vbsc1
lda #7
sta.z bs
// [2] main::wu = $4e20 -- vwuz1=vwuc1
lda #<$4e20
sta.z wu
lda #>$4e20
sta.z wu+1
// [3] main::ws = -$b1 -- vwsz1=vwsc1
lda #<-$b1
sta.z ws
lda #>-$b1
sta.z ws+1
// [4] main::du = $1e8480 -- vduz1=vduc1
lda #<$1e8480
sta.z du
lda #>$1e8480
sta.z du+1
lda #<$1e8480>>$10
sta.z du+2
lda #>$1e8480>>$10
sta.z du+3
// [5] main::ds = -$39a4f1 -- vdsz1=vdsc1
lda #<-$39a4f1
sta.z ds
lda #>-$39a4f1
sta.z ds+1
lda #<-$39a4f1>>$10
sta.z ds+2
lda #>-$39a4f1>>$10
sta.z ds+3
// [6] main::ptr = (byte*) 0 -- pbuz1=pbuc1
lda #<0
sta.z ptr
lda #>0
sta.z ptr+1
// [7] *main::SCREEN = _word0_$11 -- _deref_pwuc1=vwuc2
lda #<$11&$ffff
sta SCREEN
lda #>$11&$ffff
sta SCREEN+1
// [8] *(main::SCREEN+1*SIZEOF_WORD) = _word0_$179 -- _deref_pwuc1=vwuc2
lda #<$179&$ffff
sta SCREEN+1*SIZEOF_WORD
lda #>$179&$ffff
sta SCREEN+1*SIZEOF_WORD+1
// [9] main::$0 = _word0_ main::bu -- vwuz1=_word0_vbuz2
lda.z bu
sta.z __0
lda #0
sta.z __0+1
// [10] *(main::SCREEN+2*SIZEOF_WORD) = main::$0 -- _deref_pwuc1=vwuz1
lda.z __0
sta SCREEN+2*SIZEOF_WORD
lda.z __0+1
sta SCREEN+2*SIZEOF_WORD+1
// [11] main::$1 = _word0_ main::bs -- vwuz1=_word0_vbsz2
lda.z bs
sta.z __1
ora #$7f
bmi !+
lda #0
!:
sta.z __1+1
// [12] *(main::SCREEN+3*SIZEOF_WORD) = main::$1 -- _deref_pwuc1=vwuz1
lda.z __1
sta SCREEN+3*SIZEOF_WORD
lda.z __1+1
sta SCREEN+3*SIZEOF_WORD+1
// [13] main::$2 = _word0_ main::wu -- vwuz1=_word0_vwuz2
lda.z wu
sta.z __2
lda.z wu+1
sta.z __2+1
// [14] *(main::SCREEN+4*SIZEOF_WORD) = main::$2 -- _deref_pwuc1=vwuz1
lda.z __2
sta SCREEN+4*SIZEOF_WORD
lda.z __2+1
sta SCREEN+4*SIZEOF_WORD+1
// [15] main::$3 = _word0_ main::ws -- vwuz1=_word0_vwsz2
lda.z ws
sta.z __3
lda.z ws+1
sta.z __3+1
// [16] *(main::SCREEN+5*SIZEOF_WORD) = main::$3 -- _deref_pwuc1=vwuz1
lda.z __3
sta SCREEN+5*SIZEOF_WORD
lda.z __3+1
sta SCREEN+5*SIZEOF_WORD+1
// [17] main::$4 = _word0_ main::du -- vwuz1=_word0_vduz2
lda.z du
sta.z __4
lda.z du+1
sta.z __4+1
// [18] *(main::SCREEN+6*SIZEOF_WORD) = main::$4 -- _deref_pwuc1=vwuz1
lda.z __4
sta SCREEN+6*SIZEOF_WORD
lda.z __4+1
sta SCREEN+6*SIZEOF_WORD+1
// [19] main::$5 = _word0_ main::ds -- vwuz1=_word0_vdsz2
lda.z ds
sta.z __5
lda.z ds+1
sta.z __5+1
// [20] *(main::SCREEN+7*SIZEOF_WORD) = main::$5 -- _deref_pwuc1=vwuz1
lda.z __5
sta SCREEN+7*SIZEOF_WORD
lda.z __5+1
sta SCREEN+7*SIZEOF_WORD+1
// [21] main::$6 = _word0_ main::ptr -- vwuz1=_word0_pbuz2
lda.z ptr
sta.z __6
lda.z ptr+1
sta.z __6+1
// [22] *(main::SCREEN+8*SIZEOF_WORD) = main::$6 -- _deref_pwuc1=vwuz1
lda.z __6
sta SCREEN+8*SIZEOF_WORD
lda.z __6+1
sta SCREEN+8*SIZEOF_WORD+1
jmp __breturn
// main::@return
__breturn:
// [23] return
rts
}
// File Data
ASSEMBLER OPTIMIZATIONS
Removing instruction jmp __breturn
Succesful ASM optimization Pass5NextJumpElimination
Removing instruction lda #7
Removing instruction lda #>0
Succesful ASM optimization Pass5UnnecesaryLoadElimination
Removing instruction __breturn:
Succesful ASM optimization Pass5UnusedLabelElimination
FINAL SYMBOL TABLE
const byte SIZEOF_WORD = 2
void main()
word~ main::$0 zp[2]:18 4.0
word~ main::$1 zp[2]:20 4.0
word~ main::$2 zp[2]:22 4.0
word~ main::$3 zp[2]:24 4.0
word~ main::$4 zp[2]:26 4.0
word~ main::$5 zp[2]:28 4.0
word~ main::$6 zp[2]:30 4.0
const nomodify word* main::SCREEN = (word*) 1024
volatile signed byte main::bs loadstore zp[1]:3 0.4
volatile byte main::bu loadstore zp[1]:2 0.4444444444444444
volatile signed dword main::ds loadstore zp[4]:12 0.2857142857142857
volatile dword main::du loadstore zp[4]:8 0.3076923076923077
byte main::i
volatile byte* main::ptr loadstore zp[2]:16 0.26666666666666666
volatile signed word main::ws loadstore zp[2]:6 0.3333333333333333
volatile word main::wu loadstore zp[2]:4 0.36363636363636365
zp[1]:2 [ main::bu ]
zp[1]:3 [ main::bs ]
zp[2]:4 [ main::wu ]
zp[2]:6 [ main::ws ]
zp[4]:8 [ main::du ]
zp[4]:12 [ main::ds ]
zp[2]:16 [ main::ptr ]
zp[2]:18 [ main::$0 ]
zp[2]:20 [ main::$1 ]
zp[2]:22 [ main::$2 ]
zp[2]:24 [ main::$3 ]
zp[2]:26 [ main::$4 ]
zp[2]:28 [ main::$5 ]
zp[2]:30 [ main::$6 ]
FINAL ASSEMBLER
Score: 290
// File Comments
// Test operator WORD0()
// Upstart
// Commodore 64 PRG executable file
.file [name="operator-word0.prg", type="prg", segments="Program"]
.segmentdef Program [segments="Basic, Code, Data"]
.segmentdef Basic [start=$0801]
.segmentdef Code [start=$80d]
.segmentdef Data [startAfter="Code"]
.segment Basic
:BasicUpstart(main)
// Global Constants & labels
.const SIZEOF_WORD = 2
.segment Code
// main
main: {
.label SCREEN = $400
.label bu = 2
.label bs = 3
.label wu = 4
.label ws = 6
.label du = 8
.label ds = $c
.label ptr = $10
.label __0 = $12
.label __1 = $14
.label __2 = $16
.label __3 = $18
.label __4 = $1a
.label __5 = $1c
.label __6 = $1e
// bu = 7
// [0] main::bu = 7 -- vbuz1=vbuc1
lda #7
sta.z bu
// bs = 7
// [1] main::bs = 7 -- vbsz1=vbsc1
sta.z bs
// wu = 20000
// [2] main::wu = $4e20 -- vwuz1=vwuc1
lda #<$4e20
sta.z wu
lda #>$4e20
sta.z wu+1
// ws = -177
// [3] main::ws = -$b1 -- vwsz1=vwsc1
lda #<-$b1
sta.z ws
lda #>-$b1
sta.z ws+1
// du = 2000000
// [4] main::du = $1e8480 -- vduz1=vduc1
lda #<$1e8480
sta.z du
lda #>$1e8480
sta.z du+1
lda #<$1e8480>>$10
sta.z du+2
lda #>$1e8480>>$10
sta.z du+3
// ds = -3777777
// [5] main::ds = -$39a4f1 -- vdsz1=vdsc1
lda #<-$39a4f1
sta.z ds
lda #>-$39a4f1
sta.z ds+1
lda #<-$39a4f1>>$10
sta.z ds+2
lda #>-$39a4f1>>$10
sta.z ds+3
// ptr = 0x0000
// [6] main::ptr = (byte*) 0 -- pbuz1=pbuc1
lda #<0
sta.z ptr
sta.z ptr+1
// SCREEN[i++] = WORD0(17)
// [7] *main::SCREEN = _word0_$11 -- _deref_pwuc1=vwuc2
lda #<$11&$ffff
sta SCREEN
lda #>$11&$ffff
sta SCREEN+1
// SCREEN[i++] = WORD0(377)
// [8] *(main::SCREEN+1*SIZEOF_WORD) = _word0_$179 -- _deref_pwuc1=vwuc2
lda #<$179&$ffff
sta SCREEN+1*SIZEOF_WORD
lda #>$179&$ffff
sta SCREEN+1*SIZEOF_WORD+1
// WORD0(bu)
// [9] main::$0 = _word0_ main::bu -- vwuz1=_word0_vbuz2
lda.z bu
sta.z __0
lda #0
sta.z __0+1
// SCREEN[i++] = WORD0(bu)
// [10] *(main::SCREEN+2*SIZEOF_WORD) = main::$0 -- _deref_pwuc1=vwuz1
lda.z __0
sta SCREEN+2*SIZEOF_WORD
lda.z __0+1
sta SCREEN+2*SIZEOF_WORD+1
// WORD0(bs)
// [11] main::$1 = _word0_ main::bs -- vwuz1=_word0_vbsz2
lda.z bs
sta.z __1
ora #$7f
bmi !+
lda #0
!:
sta.z __1+1
// SCREEN[i++] = WORD0(bs)
// [12] *(main::SCREEN+3*SIZEOF_WORD) = main::$1 -- _deref_pwuc1=vwuz1
lda.z __1
sta SCREEN+3*SIZEOF_WORD
lda.z __1+1
sta SCREEN+3*SIZEOF_WORD+1
// WORD0(wu)
// [13] main::$2 = _word0_ main::wu -- vwuz1=_word0_vwuz2
lda.z wu
sta.z __2
lda.z wu+1
sta.z __2+1
// SCREEN[i++] = WORD0(wu)
// [14] *(main::SCREEN+4*SIZEOF_WORD) = main::$2 -- _deref_pwuc1=vwuz1
lda.z __2
sta SCREEN+4*SIZEOF_WORD
lda.z __2+1
sta SCREEN+4*SIZEOF_WORD+1
// WORD0(ws)
// [15] main::$3 = _word0_ main::ws -- vwuz1=_word0_vwsz2
lda.z ws
sta.z __3
lda.z ws+1
sta.z __3+1
// SCREEN[i++] = WORD0(ws)
// [16] *(main::SCREEN+5*SIZEOF_WORD) = main::$3 -- _deref_pwuc1=vwuz1
lda.z __3
sta SCREEN+5*SIZEOF_WORD
lda.z __3+1
sta SCREEN+5*SIZEOF_WORD+1
// WORD0(du)
// [17] main::$4 = _word0_ main::du -- vwuz1=_word0_vduz2
lda.z du
sta.z __4
lda.z du+1
sta.z __4+1
// SCREEN[i++] = WORD0(du)
// [18] *(main::SCREEN+6*SIZEOF_WORD) = main::$4 -- _deref_pwuc1=vwuz1
lda.z __4
sta SCREEN+6*SIZEOF_WORD
lda.z __4+1
sta SCREEN+6*SIZEOF_WORD+1
// WORD0(ds)
// [19] main::$5 = _word0_ main::ds -- vwuz1=_word0_vdsz2
lda.z ds
sta.z __5
lda.z ds+1
sta.z __5+1
// SCREEN[i++] = WORD0(ds)
// [20] *(main::SCREEN+7*SIZEOF_WORD) = main::$5 -- _deref_pwuc1=vwuz1
lda.z __5
sta SCREEN+7*SIZEOF_WORD
lda.z __5+1
sta SCREEN+7*SIZEOF_WORD+1
// WORD0(ptr)
// [21] main::$6 = _word0_ main::ptr -- vwuz1=_word0_pbuz2
lda.z ptr
sta.z __6
lda.z ptr+1
sta.z __6+1
// SCREEN[i++] = WORD0(ptr)
// [22] *(main::SCREEN+8*SIZEOF_WORD) = main::$6 -- _deref_pwuc1=vwuz1
lda.z __6
sta SCREEN+8*SIZEOF_WORD
lda.z __6+1
sta SCREEN+8*SIZEOF_WORD+1
// main::@return
// }
// [23] return
rts
}
// File Data

33
src/test/ref/operator-word0.sym Normal file
View File

@ -0,0 +1,33 @@
const byte SIZEOF_WORD = 2
void main()
word~ main::$0 zp[2]:18 4.0
word~ main::$1 zp[2]:20 4.0
word~ main::$2 zp[2]:22 4.0
word~ main::$3 zp[2]:24 4.0
word~ main::$4 zp[2]:26 4.0
word~ main::$5 zp[2]:28 4.0
word~ main::$6 zp[2]:30 4.0
const nomodify word* main::SCREEN = (word*) 1024
volatile signed byte main::bs loadstore zp[1]:3 0.4
volatile byte main::bu loadstore zp[1]:2 0.4444444444444444
volatile signed dword main::ds loadstore zp[4]:12 0.2857142857142857
volatile dword main::du loadstore zp[4]:8 0.3076923076923077
byte main::i
volatile byte* main::ptr loadstore zp[2]:16 0.26666666666666666
volatile signed word main::ws loadstore zp[2]:6 0.3333333333333333
volatile word main::wu loadstore zp[2]:4 0.36363636363636365
zp[1]:2 [ main::bu ]
zp[1]:3 [ main::bs ]
zp[2]:4 [ main::wu ]
zp[2]:6 [ main::ws ]
zp[4]:8 [ main::du ]
zp[4]:12 [ main::ds ]
zp[2]:16 [ main::ptr ]
zp[2]:18 [ main::$0 ]
zp[2]:20 [ main::$1 ]
zp[2]:22 [ main::$2 ]
zp[2]:24 [ main::$3 ]
zp[2]:26 [ main::$4 ]
zp[2]:28 [ main::$5 ]
zp[2]:30 [ main::$6 ]

81
src/test/ref/operator-word1.asm Normal file
View File

@ -0,0 +1,81 @@
// Test operator WORD1()
// Commodore 64 PRG executable file
.file [name="operator-word1.prg", type="prg", segments="Program"]
.segmentdef Program [segments="Basic, Code, Data"]
.segmentdef Basic [start=$0801]
.segmentdef Code [start=$80d]
.segmentdef Data [startAfter="Code"]
.segment Basic
:BasicUpstart(main)
.const SIZEOF_WORD = 2
.segment Code
main: {
.label SCREEN = $400
.label du = 2
.label ds = 6
.label __4 = $a
.label __5 = $c
// du = 2000000
lda #<$1e8480
sta.z du
lda #>$1e8480
sta.z du+1
lda #<$1e8480>>$10
sta.z du+2
lda #>$1e8480>>$10
sta.z du+3
// ds = -3777777
lda #<-$39a4f1
sta.z ds
lda #>-$39a4f1
sta.z ds+1
lda #<-$39a4f1>>$10
sta.z ds+2
lda #>-$39a4f1>>$10
sta.z ds+3
// SCREEN[i++] = WORD1(17)
lda #<0
sta SCREEN
sta SCREEN+1
// SCREEN[i++] = WORD1(377)
sta SCREEN+1*SIZEOF_WORD
sta SCREEN+1*SIZEOF_WORD+1
// SCREEN[i++] = WORD1(bu)
sta SCREEN+2*SIZEOF_WORD
sta SCREEN+2*SIZEOF_WORD+1
// SCREEN[i++] = WORD1(bs)
sta SCREEN+3*SIZEOF_WORD
sta SCREEN+3*SIZEOF_WORD+1
// SCREEN[i++] = WORD1(wu)
sta SCREEN+4*SIZEOF_WORD
sta SCREEN+4*SIZEOF_WORD+1
// SCREEN[i++] = WORD1(ws)
sta SCREEN+5*SIZEOF_WORD
sta SCREEN+5*SIZEOF_WORD+1
// WORD1(du)
lda.z du+2
sta.z __4
lda.z du+3
sta.z __4+1
// SCREEN[i++] = WORD1(du)
lda.z __4
sta SCREEN+6*SIZEOF_WORD
lda.z __4+1
sta SCREEN+6*SIZEOF_WORD+1
// WORD1(ds)
lda.z ds+2
sta.z __5
lda.z ds+3
sta.z __5+1
// SCREEN[i++] = WORD1(ds)
lda.z __5
sta SCREEN+7*SIZEOF_WORD
lda.z __5+1
sta SCREEN+7*SIZEOF_WORD+1
// SCREEN[i++] = WORD1(ptr)
lda #<0
sta SCREEN+8*SIZEOF_WORD
sta SCREEN+8*SIZEOF_WORD+1
// }
rts
}

20
src/test/ref/operator-word1.cfg Normal file
View File

@ -0,0 +1,20 @@
void main()
main: scope:[main] from
[0] main::du = $1e8480
[1] main::ds = -$39a4f1
[2] *main::SCREEN = 0
[3] *(main::SCREEN+1*SIZEOF_WORD) = 0
[4] *(main::SCREEN+2*SIZEOF_WORD) = 0
[5] *(main::SCREEN+3*SIZEOF_WORD) = 0
[6] *(main::SCREEN+4*SIZEOF_WORD) = 0
[7] *(main::SCREEN+5*SIZEOF_WORD) = 0
[8] main::$4 = _word1_ main::du
[9] *(main::SCREEN+6*SIZEOF_WORD) = main::$4
[10] main::$5 = _word1_ main::ds
[11] *(main::SCREEN+7*SIZEOF_WORD) = main::$5
[12] *(main::SCREEN+8*SIZEOF_WORD) = 0
to:main::@return
main::@return: scope:[main] from main
[13] return
to:@return

568
src/test/ref/operator-word1.log Normal file
View File

@ -0,0 +1,568 @@
CONTROL FLOW GRAPH SSA
void main()
main: scope:[main] from __start
main::bu = 7
main::bs = 7
main::wu = $4e20
main::ws = -$b1
main::du = $1e8480
main::ds = -$39a4f1
main::ptr = (byte*)0
main::i#0 = 0
main::$7 = main::i#0 * SIZEOF_WORD
main::SCREEN[main::$7] = _word1_$11
main::i#1 = ++ main::i#0
main::$8 = main::i#1 * SIZEOF_WORD
main::SCREEN[main::$8] = _word1_$179
main::i#2 = ++ main::i#1
main::$0 = _word1_ main::bu
main::$9 = main::i#2 * SIZEOF_WORD
main::SCREEN[main::$9] = main::$0
main::i#3 = ++ main::i#2
main::$1 = _word1_ main::bs
main::$10 = main::i#3 * SIZEOF_WORD
main::SCREEN[main::$10] = main::$1
main::i#4 = ++ main::i#3
main::$2 = _word1_ main::wu
main::$11 = main::i#4 * SIZEOF_WORD
main::SCREEN[main::$11] = main::$2
main::i#5 = ++ main::i#4
main::$3 = _word1_ main::ws
main::$12 = main::i#5 * SIZEOF_WORD
main::SCREEN[main::$12] = main::$3
main::i#6 = ++ main::i#5
main::$4 = _word1_ main::du
main::$13 = main::i#6 * SIZEOF_WORD
main::SCREEN[main::$13] = main::$4
main::i#7 = ++ main::i#6
main::$5 = _word1_ main::ds
main::$14 = main::i#7 * SIZEOF_WORD
main::SCREEN[main::$14] = main::$5
main::i#8 = ++ main::i#7
main::$6 = _word1_ main::ptr
main::$15 = main::i#8 * SIZEOF_WORD
main::SCREEN[main::$15] = main::$6
main::i#9 = ++ main::i#8
to:main::@return
main::@return: scope:[main] from main
return
to:@return
void __start()
__start: scope:[__start] from
call main
to:__start::@1
__start::@1: scope:[__start] from __start
to:__start::@return
__start::@return: scope:[__start] from __start::@1
return
to:@return
SYMBOL TABLE SSA
const byte SIZEOF_WORD = 2
void __start()
void main()
word~ main::$0
word~ main::$1
byte~ main::$10
byte~ main::$11
byte~ main::$12
byte~ main::$13
byte~ main::$14
byte~ main::$15
word~ main::$2
word~ main::$3
word~ main::$4
word~ main::$5
word~ main::$6
byte~ main::$7
byte~ main::$8
byte~ main::$9
const nomodify word* main::SCREEN = (word*)$400
volatile signed byte main::bs loadstore
volatile byte main::bu loadstore
volatile signed dword main::ds loadstore
volatile dword main::du loadstore
byte main::i
byte main::i#0
byte main::i#1
byte main::i#2
byte main::i#3
byte main::i#4
byte main::i#5
byte main::i#6
byte main::i#7
byte main::i#8
byte main::i#9
volatile byte* main::ptr loadstore
volatile signed word main::ws loadstore
volatile word main::wu loadstore
Simplifying constant pointer cast (word*) 1024
Simplifying constant pointer cast (byte*) 0
Successful SSA optimization PassNCastSimplification
Constant right-side identified [14] main::$0 = _word1_ main::bu
Constant right-side identified [18] main::$1 = _word1_ main::bs
Constant right-side identified [22] main::$2 = _word1_ main::wu
Constant right-side identified [26] main::$3 = _word1_ main::ws
Constant right-side identified [38] main::$6 = _word1_ main::ptr
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant main::i#0 = 0
Constant main::$0 = 0
Constant main::$1 = 0
Constant main::$2 = 0
Constant main::$3 = 0
Constant main::$6 = 0
Successful SSA optimization Pass2ConstantIdentification
Simplifying constant evaluating to zero _word1_$11 in [9] main::SCREEN[main::$7] = _word1_$11
Simplifying constant evaluating to zero _word1_$179 in [12] main::SCREEN[main::$8] = _word1_$179
Successful SSA optimization PassNSimplifyConstantZero
Eliminating unused variable main::bu and assignment [0] main::bu = 7
Eliminating unused variable main::bs and assignment [1] main::bs = 7
Eliminating unused variable main::wu and assignment [2] main::wu = $4e20
Eliminating unused variable main::ws and assignment [3] main::ws = -$b1
Eliminating unused variable main::ptr and assignment [6] main::ptr = (byte*) 0
Eliminating unused variable main::i#9 and assignment [35] main::i#9 = ++ main::i#8
Successful SSA optimization PassNEliminateUnusedVars
Removing unused procedure __start
Removing unused procedure block __start
Removing unused procedure block __start::@1
Removing unused procedure block __start::@return
Successful SSA optimization PassNEliminateEmptyStart
Constant right-side identified [2] main::$7 = main::i#0 * SIZEOF_WORD
Constant right-side identified [4] main::i#1 = ++ main::i#0
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant main::$7 = main::i#0*SIZEOF_WORD
Constant main::i#1 = ++main::i#0
Successful SSA optimization Pass2ConstantIdentification
Simplifying constant evaluating to zero main::i#0*SIZEOF_WORD in
Successful SSA optimization PassNSimplifyConstantZero
Simplifying expression containing zero main::SCREEN in [3] main::SCREEN[main::$7] = 0
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused constant main::$7
Successful SSA optimization PassNEliminateUnusedVars
Constant right-side identified [3] main::$8 = main::i#1 * SIZEOF_WORD
Constant right-side identified [5] main::i#2 = ++ main::i#1
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant main::$8 = main::i#1*SIZEOF_WORD
Constant main::i#2 = ++main::i#1
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [4] main::$9 = main::i#2 * SIZEOF_WORD
Constant right-side identified [6] main::i#3 = ++ main::i#2
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant main::$9 = main::i#2*SIZEOF_WORD
Constant main::i#3 = ++main::i#2
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [5] main::$10 = main::i#3 * SIZEOF_WORD
Constant right-side identified [7] main::i#4 = ++ main::i#3
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant main::$10 = main::i#3*SIZEOF_WORD
Constant main::i#4 = ++main::i#3
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [6] main::$11 = main::i#4 * SIZEOF_WORD
Constant right-side identified [8] main::i#5 = ++ main::i#4
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant main::$11 = main::i#4*SIZEOF_WORD
Constant main::i#5 = ++main::i#4
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [7] main::$12 = main::i#5 * SIZEOF_WORD
Constant right-side identified [9] main::i#6 = ++ main::i#5
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant main::$12 = main::i#5*SIZEOF_WORD
Constant main::i#6 = ++main::i#5
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [9] main::$13 = main::i#6 * SIZEOF_WORD
Constant right-side identified [11] main::i#7 = ++ main::i#6
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant main::$13 = main::i#6*SIZEOF_WORD
Constant main::i#7 = ++main::i#6
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [11] main::$14 = main::i#7 * SIZEOF_WORD
Constant right-side identified [13] main::i#8 = ++ main::i#7
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant main::$14 = main::i#7*SIZEOF_WORD
Constant main::i#8 = ++main::i#7
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [12] main::$15 = main::i#8 * SIZEOF_WORD
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant main::$15 = main::i#8*SIZEOF_WORD
Successful SSA optimization Pass2ConstantIdentification
Inlining constant with different constant siblings main::i#0
Inlining constant with different constant siblings main::i#1
Inlining constant with different constant siblings main::i#2
Inlining constant with different constant siblings main::i#3
Inlining constant with different constant siblings main::i#4
Inlining constant with different constant siblings main::i#5
Inlining constant with different constant siblings main::i#6
Inlining constant with different constant siblings main::i#7
Inlining constant with different constant siblings main::i#8
Constant inlined main::i#8 = ++++++++++++++++0
Constant inlined main::i#7 = ++++++++++++++0
Constant inlined main::i#4 = ++++++++0
Constant inlined main::i#3 = ++++++0
Constant inlined main::i#6 = ++++++++++++0
Constant inlined main::i#5 = ++++++++++0
Constant inlined main::$12 = ++++++++++0*SIZEOF_WORD
Constant inlined main::$13 = ++++++++++++0*SIZEOF_WORD
Constant inlined main::$14 = ++++++++++++++0*SIZEOF_WORD
Constant inlined main::$15 = ++++++++++++++++0*SIZEOF_WORD
Constant inlined main::$10 = ++++++0*SIZEOF_WORD
Constant inlined main::$11 = ++++++++0*SIZEOF_WORD
Constant inlined main::$1 = 0
Constant inlined main::$2 = 0
Constant inlined main::$0 = 0
Constant inlined main::i#0 = 0
Constant inlined main::$6 = 0
Constant inlined main::$3 = 0
Constant inlined main::i#2 = ++++0
Constant inlined main::i#1 = ++0
Constant inlined main::$9 = ++++0*SIZEOF_WORD
Constant inlined main::$8 = ++0*SIZEOF_WORD
Successful SSA optimization Pass2ConstantInlining
Consolidated array index constant in *(main::SCREEN+++0*SIZEOF_WORD)
Consolidated array index constant in *(main::SCREEN+++++0*SIZEOF_WORD)
Consolidated array index constant in *(main::SCREEN+++++++0*SIZEOF_WORD)
Consolidated array index constant in *(main::SCREEN+++++++++0*SIZEOF_WORD)
Consolidated array index constant in *(main::SCREEN+++++++++++0*SIZEOF_WORD)
Consolidated array index constant in *(main::SCREEN+++++++++++++0*SIZEOF_WORD)
Consolidated array index constant in *(main::SCREEN+++++++++++++++0*SIZEOF_WORD)
Consolidated array index constant in *(main::SCREEN+++++++++++++++++0*SIZEOF_WORD)
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
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
Successful SSA optimization Pass2ConstantSimplification
CALL GRAPH
Created 0 initial phi equivalence classes
Coalesced down to 0 phi equivalence classes
FINAL CONTROL FLOW GRAPH
void main()
main: scope:[main] from
[0] main::du = $1e8480
[1] main::ds = -$39a4f1
[2] *main::SCREEN = 0
[3] *(main::SCREEN+1*SIZEOF_WORD) = 0
[4] *(main::SCREEN+2*SIZEOF_WORD) = 0
[5] *(main::SCREEN+3*SIZEOF_WORD) = 0
[6] *(main::SCREEN+4*SIZEOF_WORD) = 0
[7] *(main::SCREEN+5*SIZEOF_WORD) = 0
[8] main::$4 = _word1_ main::du
[9] *(main::SCREEN+6*SIZEOF_WORD) = main::$4
[10] main::$5 = _word1_ main::ds
[11] *(main::SCREEN+7*SIZEOF_WORD) = main::$5
[12] *(main::SCREEN+8*SIZEOF_WORD) = 0
to:main::@return
main::@return: scope:[main] from main
[13] return
to:@return
VARIABLE REGISTER WEIGHTS
void main()
word~ main::$4 4.0
word~ main::$5 4.0
volatile signed dword main::ds loadstore 0.4444444444444444
volatile dword main::du loadstore 0.5
byte main::i
Initial phi equivalence classes
Added variable main::du to live range equivalence class [ main::du ]
Added variable main::ds to live range equivalence class [ main::ds ]
Added variable main::$4 to live range equivalence class [ main::$4 ]
Added variable main::$5 to live range equivalence class [ main::$5 ]
Complete equivalence classes
[ main::du ]
[ main::ds ]
[ main::$4 ]
[ main::$5 ]
Allocated zp[4]:2 [ main::du ]
Allocated zp[4]:6 [ main::ds ]
Allocated zp[2]:10 [ main::$4 ]
Allocated zp[2]:12 [ main::$5 ]
REGISTER UPLIFT POTENTIAL REGISTERS
Statement [0] main::du = $1e8480 [ main::du ] ( [ main::du ] { } ) always clobbers reg byte a
Statement [1] main::ds = -$39a4f1 [ main::du main::ds ] ( [ main::du main::ds ] { } ) always clobbers reg byte a
Statement [2] *main::SCREEN = 0 [ main::du main::ds ] ( [ main::du main::ds ] { } ) always clobbers reg byte a
Statement [3] *(main::SCREEN+1*SIZEOF_WORD) = 0 [ main::du main::ds ] ( [ main::du main::ds ] { } ) always clobbers reg byte a
Statement [4] *(main::SCREEN+2*SIZEOF_WORD) = 0 [ main::du main::ds ] ( [ main::du main::ds ] { } ) always clobbers reg byte a
Statement [5] *(main::SCREEN+3*SIZEOF_WORD) = 0 [ main::du main::ds ] ( [ main::du main::ds ] { } ) always clobbers reg byte a
Statement [6] *(main::SCREEN+4*SIZEOF_WORD) = 0 [ main::du main::ds ] ( [ main::du main::ds ] { } ) always clobbers reg byte a
Statement [7] *(main::SCREEN+5*SIZEOF_WORD) = 0 [ main::du main::ds ] ( [ main::du main::ds ] { } ) always clobbers reg byte a
Statement [8] main::$4 = _word1_ main::du [ main::ds main::$4 ] ( [ main::ds main::$4 ] { } ) always clobbers reg byte a
Statement [9] *(main::SCREEN+6*SIZEOF_WORD) = main::$4 [ main::ds ] ( [ main::ds ] { } ) always clobbers reg byte a
Statement [10] main::$5 = _word1_ main::ds [ main::$5 ] ( [ main::$5 ] { } ) always clobbers reg byte a
Statement [11] *(main::SCREEN+7*SIZEOF_WORD) = main::$5 [ ] ( [ ] { } ) always clobbers reg byte a
Statement [12] *(main::SCREEN+8*SIZEOF_WORD) = 0 [ ] ( [ ] { } ) always clobbers reg byte a
Potential registers zp[4]:2 [ main::du ] : zp[4]:2 ,
Potential registers zp[4]:6 [ main::ds ] : zp[4]:6 ,
Potential registers zp[2]:10 [ main::$4 ] : zp[2]:10 ,
Potential registers zp[2]:12 [ main::$5 ] : zp[2]:12 ,
REGISTER UPLIFT SCOPES
Uplift Scope [main] 4: zp[2]:10 [ main::$4 ] 4: zp[2]:12 [ main::$5 ] 0.5: zp[4]:2 [ main::du ] 0.44: zp[4]:6 [ main::ds ]
Uplift Scope []
Uplifting [main] best 185 combination zp[2]:10 [ main::$4 ] zp[2]:12 [ main::$5 ] zp[4]:2 [ main::du ] zp[4]:6 [ main::ds ]
Uplifting [] best 185 combination
ASSEMBLER BEFORE OPTIMIZATION
// File Comments
// Test operator WORD1()
// Upstart
// Commodore 64 PRG executable file
.file [name="operator-word1.prg", type="prg", segments="Program"]
.segmentdef Program [segments="Basic, Code, Data"]
.segmentdef Basic [start=$0801]
.segmentdef Code [start=$80d]
.segmentdef Data [startAfter="Code"]
.segment Basic
:BasicUpstart(main)
// Global Constants & labels
.const SIZEOF_WORD = 2
.segment Code
// main
main: {
.label SCREEN = $400
.label du = 2
.label ds = 6
.label __4 = $a
.label __5 = $c
// [0] main::du = $1e8480 -- vduz1=vduc1
lda #<$1e8480
sta.z du
lda #>$1e8480
sta.z du+1
lda #<$1e8480>>$10
sta.z du+2
lda #>$1e8480>>$10
sta.z du+3
// [1] main::ds = -$39a4f1 -- vdsz1=vdsc1
lda #<-$39a4f1
sta.z ds
lda #>-$39a4f1
sta.z ds+1
lda #<-$39a4f1>>$10
sta.z ds+2
lda #>-$39a4f1>>$10
sta.z ds+3
// [2] *main::SCREEN = 0 -- _deref_pwuc1=vwuc2
lda #<0
sta SCREEN
lda #>0
sta SCREEN+1
// [3] *(main::SCREEN+1*SIZEOF_WORD) = 0 -- _deref_pwuc1=vwuc2
lda #<0
sta SCREEN+1*SIZEOF_WORD
lda #>0
sta SCREEN+1*SIZEOF_WORD+1
// [4] *(main::SCREEN+2*SIZEOF_WORD) = 0 -- _deref_pwuc1=vwuc2
lda #<0
sta SCREEN+2*SIZEOF_WORD
lda #>0
sta SCREEN+2*SIZEOF_WORD+1
// [5] *(main::SCREEN+3*SIZEOF_WORD) = 0 -- _deref_pwuc1=vwuc2
lda #<0
sta SCREEN+3*SIZEOF_WORD
lda #>0
sta SCREEN+3*SIZEOF_WORD+1
// [6] *(main::SCREEN+4*SIZEOF_WORD) = 0 -- _deref_pwuc1=vwuc2
lda #<0
sta SCREEN+4*SIZEOF_WORD
lda #>0
sta SCREEN+4*SIZEOF_WORD+1
// [7] *(main::SCREEN+5*SIZEOF_WORD) = 0 -- _deref_pwuc1=vwuc2
lda #<0
sta SCREEN+5*SIZEOF_WORD
lda #>0
sta SCREEN+5*SIZEOF_WORD+1
// [8] main::$4 = _word1_ main::du -- vwuz1=_word1_vduz2
lda.z du+2
sta.z __4
lda.z du+3
sta.z __4+1
// [9] *(main::SCREEN+6*SIZEOF_WORD) = main::$4 -- _deref_pwuc1=vwuz1
lda.z __4
sta SCREEN+6*SIZEOF_WORD
lda.z __4+1
sta SCREEN+6*SIZEOF_WORD+1
// [10] main::$5 = _word1_ main::ds -- vwuz1=_word1_vdsz2
lda.z ds+2
sta.z __5
lda.z ds+3
sta.z __5+1
// [11] *(main::SCREEN+7*SIZEOF_WORD) = main::$5 -- _deref_pwuc1=vwuz1
lda.z __5
sta SCREEN+7*SIZEOF_WORD
lda.z __5+1
sta SCREEN+7*SIZEOF_WORD+1
// [12] *(main::SCREEN+8*SIZEOF_WORD) = 0 -- _deref_pwuc1=vwuc2
lda #<0
sta SCREEN+8*SIZEOF_WORD
lda #>0
sta SCREEN+8*SIZEOF_WORD+1
jmp __breturn
// main::@return
__breturn:
// [13] return
rts
}
// File Data
ASSEMBLER OPTIMIZATIONS
Removing instruction jmp __breturn
Succesful ASM optimization Pass5NextJumpElimination
Removing instruction lda #>0
Removing instruction lda #<0
Removing instruction lda #>0
Removing instruction lda #<0
Removing instruction lda #>0
Removing instruction lda #<0
Removing instruction lda #>0
Removing instruction lda #<0
Removing instruction lda #>0
Removing instruction lda #<0
Removing instruction lda #>0
Removing instruction lda #>0
Succesful ASM optimization Pass5UnnecesaryLoadElimination
Removing instruction __breturn:
Succesful ASM optimization Pass5UnusedLabelElimination
FINAL SYMBOL TABLE
const byte SIZEOF_WORD = 2
void main()
word~ main::$4 zp[2]:10 4.0
word~ main::$5 zp[2]:12 4.0
const nomodify word* main::SCREEN = (word*) 1024
volatile signed dword main::ds loadstore zp[4]:6 0.4444444444444444
volatile dword main::du loadstore zp[4]:2 0.5
byte main::i
zp[4]:2 [ main::du ]
zp[4]:6 [ main::ds ]
zp[2]:10 [ main::$4 ]
zp[2]:12 [ main::$5 ]
FINAL ASSEMBLER
Score: 158
// File Comments
// Test operator WORD1()
// Upstart
// Commodore 64 PRG executable file
.file [name="operator-word1.prg", type="prg", segments="Program"]
.segmentdef Program [segments="Basic, Code, Data"]
.segmentdef Basic [start=$0801]
.segmentdef Code [start=$80d]
.segmentdef Data [startAfter="Code"]
.segment Basic
:BasicUpstart(main)
// Global Constants & labels
.const SIZEOF_WORD = 2
.segment Code
// main
main: {
.label SCREEN = $400
.label du = 2
.label ds = 6
.label __4 = $a
.label __5 = $c
// du = 2000000
// [0] main::du = $1e8480 -- vduz1=vduc1
lda #<$1e8480
sta.z du
lda #>$1e8480
sta.z du+1
lda #<$1e8480>>$10
sta.z du+2
lda #>$1e8480>>$10
sta.z du+3
// ds = -3777777
// [1] main::ds = -$39a4f1 -- vdsz1=vdsc1
lda #<-$39a4f1
sta.z ds
lda #>-$39a4f1
sta.z ds+1
lda #<-$39a4f1>>$10
sta.z ds+2
lda #>-$39a4f1>>$10
sta.z ds+3
// SCREEN[i++] = WORD1(17)
// [2] *main::SCREEN = 0 -- _deref_pwuc1=vwuc2
lda #<0
sta SCREEN
sta SCREEN+1
// SCREEN[i++] = WORD1(377)
// [3] *(main::SCREEN+1*SIZEOF_WORD) = 0 -- _deref_pwuc1=vwuc2
sta SCREEN+1*SIZEOF_WORD
sta SCREEN+1*SIZEOF_WORD+1
// SCREEN[i++] = WORD1(bu)
// [4] *(main::SCREEN+2*SIZEOF_WORD) = 0 -- _deref_pwuc1=vwuc2
sta SCREEN+2*SIZEOF_WORD
sta SCREEN+2*SIZEOF_WORD+1
// SCREEN[i++] = WORD1(bs)
// [5] *(main::SCREEN+3*SIZEOF_WORD) = 0 -- _deref_pwuc1=vwuc2
sta SCREEN+3*SIZEOF_WORD
sta SCREEN+3*SIZEOF_WORD+1
// SCREEN[i++] = WORD1(wu)
// [6] *(main::SCREEN+4*SIZEOF_WORD) = 0 -- _deref_pwuc1=vwuc2
sta SCREEN+4*SIZEOF_WORD
sta SCREEN+4*SIZEOF_WORD+1
// SCREEN[i++] = WORD1(ws)
// [7] *(main::SCREEN+5*SIZEOF_WORD) = 0 -- _deref_pwuc1=vwuc2
sta SCREEN+5*SIZEOF_WORD
sta SCREEN+5*SIZEOF_WORD+1
// WORD1(du)
// [8] main::$4 = _word1_ main::du -- vwuz1=_word1_vduz2
lda.z du+2
sta.z __4
lda.z du+3
sta.z __4+1
// SCREEN[i++] = WORD1(du)
// [9] *(main::SCREEN+6*SIZEOF_WORD) = main::$4 -- _deref_pwuc1=vwuz1
lda.z __4
sta SCREEN+6*SIZEOF_WORD
lda.z __4+1
sta SCREEN+6*SIZEOF_WORD+1
// WORD1(ds)
// [10] main::$5 = _word1_ main::ds -- vwuz1=_word1_vdsz2
lda.z ds+2
sta.z __5
lda.z ds+3
sta.z __5+1
// SCREEN[i++] = WORD1(ds)
// [11] *(main::SCREEN+7*SIZEOF_WORD) = main::$5 -- _deref_pwuc1=vwuz1
lda.z __5
sta SCREEN+7*SIZEOF_WORD
lda.z __5+1
sta SCREEN+7*SIZEOF_WORD+1
// SCREEN[i++] = WORD1(ptr)
// [12] *(main::SCREEN+8*SIZEOF_WORD) = 0 -- _deref_pwuc1=vwuc2
lda #<0
sta SCREEN+8*SIZEOF_WORD
sta SCREEN+8*SIZEOF_WORD+1
// main::@return
// }
// [13] return
rts
}
// File Data

13
src/test/ref/operator-word1.sym Normal file
View File

@ -0,0 +1,13 @@
const byte SIZEOF_WORD = 2
void main()
word~ main::$4 zp[2]:10 4.0
word~ main::$5 zp[2]:12 4.0
const nomodify word* main::SCREEN = (word*) 1024
volatile signed dword main::ds loadstore zp[4]:6 0.4444444444444444
volatile dword main::du loadstore zp[4]:2 0.5
byte main::i
zp[4]:2 [ main::du ]
zp[4]:6 [ main::ds ]
zp[2]:10 [ main::$4 ]
zp[2]:12 [ main::$5 ]