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

Added 8bit unsigned division. Ensured that pointers are generated into ASM labels.

Browse Source
This commit is contained in:
jespergravgaard 2018-01-31 21:27:22 +01:00
parent b466f2f5cc
commit e0124ee654
137 changed files with 4862 additions and 588 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/main/java/dk/camelot64/kickc/asm/AsmLabelDecl.java
View File

@ -1,17 +1,15 @@
package dk.camelot64.kickc.asm;
import dk.camelot64.kickc.fragment.AsmFormat;
/** A label declaration .label lbl = val */
public class AsmLabelDecl implements AsmLine {
private final String name;
private final int address;
private final String value;
private int index;
public AsmLabelDecl(String name, int address) {
public AsmLabelDecl(String name, String value) {
this.name = name;
this.address = address;
this.value = value;
}
@Override
@ -26,7 +24,7 @@ public class AsmLabelDecl implements AsmLine {
@Override
public String getAsm() {
return ".label " + name + " = " + AsmFormat.getAsmNumber(address);
return ".label " + name + " = " + value;
}
@Override

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

@ -1,5 +1,7 @@
package dk.camelot64.kickc.asm;
import dk.camelot64.kickc.fragment.AsmFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
@ -71,7 +73,11 @@ public class AsmProgram {
}
public void addLabelDecl(String name, int address) {
addLine(new AsmLabelDecl(name, address));
addLabelDecl(name, AsmFormat.getAsmNumber(address));
}
public void addLabelDecl(String name, String value) {
addLine(new AsmLabelDecl(name, value));
}
/**

9
src/main/java/dk/camelot64/kickc/passes/Pass4CodeGeneration.java
View File

@ -110,8 +110,15 @@ public class Pass4CodeGeneration {
if(!(constantVar.getValue() instanceof ConstantArrayList || constantVar.getValue() instanceof ConstantArrayFilled || constantVar.getType().equals(SymbolType.STRING))) {
String asmName = constantVar.getAsmName() == null ? constantVar.getLocalName() : constantVar.getAsmName();
if(asmName != null && !added.contains(asmName)) {
asm.addConstant(asmName.replace("#", "_").replace("$", "_"), AsmFormat.getAsmConstant(program, constantVar.getValue(), 99, scopeRef));
added.add(asmName);
String asmConstant = AsmFormat.getAsmConstant(program, constantVar.getValue(), 99, scopeRef);
if(constantVar.getType() instanceof SymbolTypePointer) {
// Must use a label for pointers
asm.addLabelDecl(asmName.replace("#", "_").replace("$", "_"), asmConstant);
} else {
// Use constant for non-pointers
asm.addConstant(asmName.replace("#", "_").replace("$", "_"), asmConstant);
}
}
}
}

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

@ -42,6 +42,12 @@ public class TestPrograms {
AsmFragmentTemplateUsages.logUsages(log, false, false, false, false, false, false);
}
@Test
public void testDivision() throws IOException, URISyntaxException {
compileAndCompare("division");
}
@Test
public void testVarRegister() throws IOException, URISyntaxException {
compileAndCompare("var-register");

48
src/test/java/dk/camelot64/kickc/test/kc/division.kc Normal file
View File

@ -0,0 +1,48 @@
import "print.kc"
const byte* NULL = 0;
void main() {
byte* rem = $ff;
byte[] dividends = { 255, 255, 255, 255, 255, 255};
byte[] divisors = { 5, 7, 11, 13, 17, 19 };
print_cls();
for( byte i: 0..5 ) {
byte dividend = dividends[i];
byte divisor = divisors[i];
byte res = div8u(dividend, divisor, rem);
print_byte(dividend);
print_str(" / @");
print_byte(divisor);
print_str(" = @");
print_byte(res);
print_str(" @");
print_byte(*rem);
print_ln();
}
}
// Performs division on two 8 bit unsigned bytes
// Returns dividend/divisor.
// If remainder is non-null it will be set to the remainder.
// Implemented using simple binary division
byte div8u(byte dividend, byte divisor, byte* remainder) {
byte rem = 0;
byte quotient = 0;
for( byte i : 0..7) {
rem = rem << 1;
if( (dividend & $80) != 0 ) {
rem++;
}
dividend = dividend << 1;
quotient = quotient << 1;
if(rem>=divisor) {
quotient++;
rem = rem - divisor;
}
}
*remainder = rem;
return quotient;
}

2
src/test/java/dk/camelot64/kickc/test/ref/arrays-init.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.label SCREEN = $400
jsr main
main: {
lda #'c'

6
src/test/java/dk/camelot64/kickc/test/ref/arrays-init.log
View File

@ -212,7 +212,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -270,7 +270,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -350,7 +350,7 @@ Score: 38
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
//SEG4 @1

2
src/test/java/dk/camelot64/kickc/test/ref/asm-clobber.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.label SCREEN = $400
jsr main
main: {
.label l = 2

6
src/test/java/dk/camelot64/kickc/test/ref/asm-clobber.log
View File

@ -457,7 +457,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -606,7 +606,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -795,7 +795,7 @@ Score: 4682
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
//SEG4 @1

12
src/test/java/dk/camelot64/kickc/test/ref/bitmap-bresenham.asm
View File

@ -1,15 +1,15 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const BGCOL = $d020
.const FGCOL = $d021
.const D018 = $d018
.const D011 = $d011
.label BGCOL = $d020
.label FGCOL = $d021
.label D018 = $d018
.label D011 = $d011
.const BMM = $20
.const DEN = $10
.const RSEL = 8
.const SCREEN = $400
.const BITMAP = $2000
.label SCREEN = $400
.label BITMAP = $2000
.const lines_cnt = 8
jsr main
main: {

36
src/test/java/dk/camelot64/kickc/test/ref/bitmap-bresenham.log
View File

@ -4252,15 +4252,15 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const BGCOL = $d020
.const FGCOL = $d021
.const D018 = $d018
.const D011 = $d011
.label BGCOL = $d020
.label FGCOL = $d021
.label D018 = $d018
.label D011 = $d011
.const BMM = $20
.const DEN = $10
.const RSEL = 8
.const SCREEN = $400
.const BITMAP = $2000
.label SCREEN = $400
.label BITMAP = $2000
.const lines_cnt = 8
//SEG2 @begin
bbegin:
@ -5603,15 +5603,15 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const BGCOL = $d020
.const FGCOL = $d021
.const D018 = $d018
.const D011 = $d011
.label BGCOL = $d020
.label FGCOL = $d021
.label D018 = $d018
.label D011 = $d011
.const BMM = $20
.const DEN = $10
.const RSEL = 8
.const SCREEN = $400
.const BITMAP = $2000
.label SCREEN = $400
.label BITMAP = $2000
.const lines_cnt = 8
//SEG2 @begin
bbegin:
@ -7062,15 +7062,15 @@ Score: 218375
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const BGCOL = $d020
.const FGCOL = $d021
.const D018 = $d018
.const D011 = $d011
.label BGCOL = $d020
.label FGCOL = $d021
.label D018 = $d018
.label D011 = $d011
.const BMM = $20
.const DEN = $10
.const RSEL = 8
.const SCREEN = $400
.const BITMAP = $2000
.label SCREEN = $400
.label BITMAP = $2000
.const lines_cnt = 8
//SEG2 @begin
//SEG3 [1] phi from @begin to @10 [phi:@begin->@10]

14
src/test/java/dk/camelot64/kickc/test/ref/bitmap-plotter.asm
View File

@ -1,16 +1,16 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const D011 = $d011
.label D011 = $d011
.const BMM = $20
.const DEN = $10
.const RSEL = 8
.const RASTER = $d012
.const D018 = $d018
.const BGCOL = $d020
.const FGCOL = $d021
.const SCREEN = $400
.const BITMAP = $2000
.label RASTER = $d012
.label D018 = $d018
.label BGCOL = $d020
.label FGCOL = $d021
.label SCREEN = $400
.label BITMAP = $2000
.const plots_cnt = 8
jsr main
main: {

42
src/test/java/dk/camelot64/kickc/test/ref/bitmap-plotter.log
View File

@ -1746,16 +1746,16 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const D011 = $d011
.label D011 = $d011
.const BMM = $20
.const DEN = $10
.const RSEL = 8
.const RASTER = $d012
.const D018 = $d018
.const BGCOL = $d020
.const FGCOL = $d021
.const SCREEN = $400
.const BITMAP = $2000
.label RASTER = $d012
.label D018 = $d018
.label BGCOL = $d020
.label FGCOL = $d021
.label SCREEN = $400
.label BITMAP = $2000
.const plots_cnt = 8
//SEG2 @begin
bbegin:
@ -2284,16 +2284,16 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const D011 = $d011
.label D011 = $d011
.const BMM = $20
.const DEN = $10
.const RSEL = 8
.const RASTER = $d012
.const D018 = $d018
.const BGCOL = $d020
.const FGCOL = $d021
.const SCREEN = $400
.const BITMAP = $2000
.label RASTER = $d012
.label D018 = $d018
.label BGCOL = $d020
.label FGCOL = $d021
.label SCREEN = $400
.label BITMAP = $2000
.const plots_cnt = 8
//SEG2 @begin
bbegin:
@ -2883,16 +2883,16 @@ Score: 6207
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const D011 = $d011
.label D011 = $d011
.const BMM = $20
.const DEN = $10
.const RSEL = 8
.const RASTER = $d012
.const D018 = $d018
.const BGCOL = $d020
.const FGCOL = $d021
.const SCREEN = $400
.const BITMAP = $2000
.label RASTER = $d012
.label D018 = $d018
.label BGCOL = $d020
.label FGCOL = $d021
.label SCREEN = $400
.label BITMAP = $2000
.const plots_cnt = 8
//SEG2 @begin
//SEG3 [1] phi from @begin to @5 [phi:@begin->@5]

2
src/test/java/dk/camelot64/kickc/test/ref/bresenham.asm
View File

@ -2,7 +2,7 @@
:BasicUpstart(main)
.pc = $80d "Program"
.const STAR = $51
.const SCREEN = $400
.label SCREEN = $400
jsr main
main: {
.const x1 = $27

6
src/test/java/dk/camelot64/kickc/test/ref/bresenham.log
View File

@ -586,7 +586,7 @@ INITIAL ASM
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const STAR = $51
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -736,7 +736,7 @@ ASSEMBLER BEFORE OPTIMIZATION
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const STAR = $51
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -929,7 +929,7 @@ Score: 992
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const STAR = $51
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
//SEG4 @1

2
src/test/java/dk/camelot64/kickc/test/ref/bresenhamarr.asm
View File

@ -4,7 +4,7 @@
jsr main
main: {
.const STAR = $51
.const screen = $400
.label screen = $400
.const x1 = $27
.const y1 = $18
.const xd = x1-0

6
src/test/java/dk/camelot64/kickc/test/ref/bresenhamarr.log
View File

@ -587,7 +587,7 @@ bend:
//SEG9 main
main: {
.const STAR = $51
.const screen = $400
.label screen = $400
.const x1 = $27
.const y1 = $18
.const xd = x1-0
@ -739,7 +739,7 @@ bend:
//SEG9 main
main: {
.const STAR = $51
.const screen = $400
.label screen = $400
.const x1 = $27
.const y1 = $18
.const xd = x1-0
@ -930,7 +930,7 @@ Score: 1112
//SEG9 main
main: {
.const STAR = $51
.const screen = $400
.label screen = $400
.const x1 = $27
.const y1 = $18
.const xd = x1-0

2
src/test/java/dk/camelot64/kickc/test/ref/cast-deref.asm
View File

@ -3,7 +3,7 @@
.pc = $80d "Program"
jsr main
main: {
.const SCREEN = $400
.label SCREEN = $400
ldx #0
b1:
lda sbs,x

6
src/test/java/dk/camelot64/kickc/test/ref/cast-deref.log
View File

@ -267,7 +267,7 @@ bend_from_b1:
bend:
//SEG9 main
main: {
.const SCREEN = $400
.label SCREEN = $400
.label i = 2
//SEG10 [5] phi from main to main::@1 [phi:main->main::@1]
b1_from_main:
@ -336,7 +336,7 @@ bend_from_b1:
bend:
//SEG9 main
main: {
.const SCREEN = $400
.label SCREEN = $400
//SEG10 [5] phi from main to main::@1 [phi:main->main::@1]
b1_from_main:
//SEG11 [5] phi (byte) main::i#2 = (byte/signed byte/word/signed word/dword/signed dword) 0 [phi:main->main::@1#0] -- vbuxx=vbuc1
@ -421,7 +421,7 @@ Score: 192
//SEG8 @end
//SEG9 main
main: {
.const SCREEN = $400
.label SCREEN = $400
//SEG10 [5] phi from main to main::@1 [phi:main->main::@1]
//SEG11 [5] phi (byte) main::i#2 = (byte/signed byte/word/signed word/dword/signed dword) 0 [phi:main->main::@1#0] -- vbuxx=vbuc1
ldx #0

8
src/test/java/dk/camelot64/kickc/test/ref/casting.asm
View File

@ -1,10 +1,10 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.const SCREEN2 = SCREEN+$28*3
.const SCREEN3 = SCREEN+$28*6
.const SCREEN4 = SCREEN+$28*9
.label SCREEN = $400
.label SCREEN2 = SCREEN+$28*3
.label SCREEN3 = SCREEN+$28*6
.label SCREEN4 = SCREEN+$28*9
jsr main
main: {
ldx #0

24
src/test/java/dk/camelot64/kickc/test/ref/casting.log
View File

@ -603,10 +603,10 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.const SCREEN2 = SCREEN+$28*3
.const SCREEN3 = SCREEN+$28*6
.const SCREEN4 = SCREEN+$28*9
.label SCREEN = $400
.label SCREEN2 = SCREEN+$28*3
.label SCREEN3 = SCREEN+$28*6
.label SCREEN4 = SCREEN+$28*9
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @2 [phi:@begin->@2]
@ -760,10 +760,10 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.const SCREEN2 = SCREEN+$28*3
.const SCREEN3 = SCREEN+$28*6
.const SCREEN4 = SCREEN+$28*9
.label SCREEN = $400
.label SCREEN2 = SCREEN+$28*3
.label SCREEN3 = SCREEN+$28*6
.label SCREEN4 = SCREEN+$28*9
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @2 [phi:@begin->@2]
@ -951,10 +951,10 @@ Score: 674
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.const SCREEN2 = SCREEN+$28*3
.const SCREEN3 = SCREEN+$28*6
.const SCREEN4 = SCREEN+$28*9
.label SCREEN = $400
.label SCREEN2 = SCREEN+$28*3
.label SCREEN3 = SCREEN+$28*6
.label SCREEN4 = SCREEN+$28*9
//SEG2 @begin
//SEG3 [1] phi from @begin to @2 [phi:@begin->@2]
//SEG4 @2

8
src/test/java/dk/camelot64/kickc/test/ref/chargen.asm
View File

@ -1,12 +1,12 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const PROCPORT = 1
.const CHARGEN = $d000
.const SCREEN = $400
.label PROCPORT = 1
.label CHARGEN = $d000
.label SCREEN = $400
jsr main
main: {
.const CHAR_A = CHARGEN+8
.label CHAR_A = CHARGEN+8
.label bits = 3
.label sc = 4
.label y = 2

24
src/test/java/dk/camelot64/kickc/test/ref/chargen.log
View File

@ -615,9 +615,9 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const PROCPORT = 1
.const CHARGEN = $d000
.const SCREEN = $400
.label PROCPORT = 1
.label CHARGEN = $d000
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -634,7 +634,7 @@ bend_from_b1:
bend:
//SEG8 main
main: {
.const CHAR_A = CHARGEN+8
.label CHAR_A = CHARGEN+8
.label _1 = 8
.label bits = 3
.label sc = 4
@ -801,9 +801,9 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const PROCPORT = 1
.const CHARGEN = $d000
.const SCREEN = $400
.label PROCPORT = 1
.label CHARGEN = $d000
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -820,7 +820,7 @@ bend_from_b1:
bend:
//SEG8 main
main: {
.const CHAR_A = CHARGEN+8
.label CHAR_A = CHARGEN+8
.label bits = 3
.label sc = 4
.label y = 2
@ -1027,9 +1027,9 @@ Score: 5633
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const PROCPORT = 1
.const CHARGEN = $d000
.const SCREEN = $400
.label PROCPORT = 1
.label CHARGEN = $d000
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
//SEG4 @1
@ -1039,7 +1039,7 @@ Score: 5633
//SEG7 @end
//SEG8 main
main: {
.const CHAR_A = CHARGEN+8
.label CHAR_A = CHARGEN+8
.label bits = 3
.label sc = 4
.label y = 2

4
src/test/java/dk/camelot64/kickc/test/ref/const-identification.asm
View File

@ -1,8 +1,8 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const plots = $1000
.const SCREEN = $400
.label plots = $1000
.label SCREEN = $400
jsr main
main: {
ldx #0

12
src/test/java/dk/camelot64/kickc/test/ref/const-identification.log
View File

@ -560,8 +560,8 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const plots = $1000
.const SCREEN = $400
.label plots = $1000
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @3 [phi:@begin->@3]
@ -746,8 +746,8 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const plots = $1000
.const SCREEN = $400
.label plots = $1000
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @3 [phi:@begin->@3]
@ -977,8 +977,8 @@ Score: 2223
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const plots = $1000
.const SCREEN = $400
.label plots = $1000
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @3 [phi:@begin->@3]
//SEG4 @3

2
src/test/java/dk/camelot64/kickc/test/ref/constabsmin.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.label SCREEN = $400
jsr main
main: {
lda #1

6
src/test/java/dk/camelot64/kickc/test/ref/constabsmin.log
View File

@ -133,7 +133,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -176,7 +176,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -236,7 +236,7 @@ Score: 18
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
//SEG4 @1

2
src/test/java/dk/camelot64/kickc/test/ref/constant-string-concat.asm
View File

@ -3,7 +3,7 @@
.pc = $80d "Program"
jsr main
main: {
.const SCREEN = $400
.label SCREEN = $400
ldx #0
b1:
lda s5,x

6
src/test/java/dk/camelot64/kickc/test/ref/constant-string-concat.log
View File

@ -334,7 +334,7 @@ bend_from_b1:
bend:
//SEG9 main
main: {
.const SCREEN = $400
.label SCREEN = $400
.label i = 2
//SEG10 [5] phi from main to main::@1 [phi:main->main::@1]
b1_from_main:
@ -403,7 +403,7 @@ bend_from_b1:
bend:
//SEG9 main
main: {
.const SCREEN = $400
.label SCREEN = $400
//SEG10 [5] phi from main to main::@1 [phi:main->main::@1]
b1_from_main:
//SEG11 [5] phi (byte) main::i#2 = (byte/signed byte/word/signed word/dword/signed dword) 0 [phi:main->main::@1#0] -- vbuxx=vbuc1
@ -493,7 +493,7 @@ Score: 192
//SEG8 @end
//SEG9 main
main: {
.const SCREEN = $400
.label SCREEN = $400
//SEG10 [5] phi from main to main::@1 [phi:main->main::@1]
//SEG11 [5] phi (byte) main::i#2 = (byte/signed byte/word/signed word/dword/signed dword) 0 [phi:main->main::@1#0] -- vbuxx=vbuc1
ldx #0

6
src/test/java/dk/camelot64/kickc/test/ref/constantmin.asm
View File

@ -1,11 +1,11 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.label SCREEN = $400
.const STAR = $51
.const VIC = $d000
.label VIC = $d000
.const RED = 2
.const BGCOL = VIC+$10*2+1
.label BGCOL = VIC+$10*2+1
jsr main
main: {
lda #STAR

18
src/test/java/dk/camelot64/kickc/test/ref/constantmin.log
View File

@ -289,11 +289,11 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
.const STAR = $51
.const VIC = $d000
.label VIC = $d000
.const RED = 2
.const BGCOL = VIC+$10*2+1
.label BGCOL = VIC+$10*2+1
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -369,11 +369,11 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
.const STAR = $51
.const VIC = $d000
.label VIC = $d000
.const RED = 2
.const BGCOL = VIC+$10*2+1
.label BGCOL = VIC+$10*2+1
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -474,11 +474,11 @@ Score: 179
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
.const STAR = $51
.const VIC = $d000
.label VIC = $d000
.const RED = 2
.const BGCOL = VIC+$10*2+1
.label BGCOL = VIC+$10*2+1
//SEG2 @begin
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
//SEG4 @1

2
src/test/java/dk/camelot64/kickc/test/ref/constants.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const BGCOL = $d021
.label BGCOL = $d021
.const GREEN = 5
.const RED = 2
.label char_cursor = 2

6
src/test/java/dk/camelot64/kickc/test/ref/constants.log
View File

@ -2368,7 +2368,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const BGCOL = $d021
.label BGCOL = $d021
.const GREEN = 5
.const RED = 2
.label char_cursor = 6
@ -3005,7 +3005,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const BGCOL = $d021
.label BGCOL = $d021
.const GREEN = 5
.const RED = 2
.label char_cursor = 2
@ -3787,7 +3787,7 @@ Score: 1858
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const BGCOL = $d021
.label BGCOL = $d021
.const GREEN = 5
.const RED = 2
.label char_cursor = 2

199
src/test/java/dk/camelot64/kickc/test/ref/division.asm Normal file
View File

@ -0,0 +1,199 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.label char_cursor = 5
.label line_cursor = 3
jsr main
main: {
.label rem = $ff
.label dividend = $b
.label divisor = $c
.label res = 9
.label i = 2
jsr print_cls
lda #<$400
sta line_cursor
lda #>$400
sta line_cursor+1
lda #<$400
sta char_cursor
lda #>$400
sta char_cursor+1
lda #0
sta i
b1:
ldy i
lda dividends,y
sta dividend
lda divisors,y
sta divisor
lda dividend
sta div8u.dividend
jsr div8u
lda div8u.return
sta res
ldx dividend
jsr print_byte
lda #<str
sta print_str.str
lda #>str
sta print_str.str+1
jsr print_str
ldx divisor
jsr print_byte
lda #<str1
sta print_str.str
lda #>str1
sta print_str.str+1
jsr print_str
ldx res
jsr print_byte
lda #<str2
sta print_str.str
lda #>str2
sta print_str.str+1
jsr print_str
ldx rem
jsr print_byte
jsr print_ln
inc i
lda i
cmp #6
bne b13
rts
b13:
lda line_cursor
sta char_cursor
lda line_cursor+1
sta char_cursor+1
jmp b1
str: .text " / @"
str1: .text " = @"
str2: .text " @"
dividends: .byte $ff, $ff, $ff, $ff, $ff, $ff
divisors: .byte 5, 7, $b, $d, $11, $13
}
print_ln: {
b1:
lda line_cursor
clc
adc #$28
sta line_cursor
bcc !+
inc line_cursor+1
!:
lda line_cursor+1
cmp char_cursor+1
bcc b1
bne !+
lda line_cursor
cmp char_cursor
bcc b1
!:
rts
}
print_byte: {
txa
lsr
lsr
lsr
lsr
tay
lda hextab,y
jsr print_char
txa
and #$f
tay
lda hextab,y
jsr print_char
rts
hextab: .text "0123456789abcdef"
}
print_char: {
ldy #0
sta (char_cursor),y
inc char_cursor
bne !+
inc char_cursor+1
!:
rts
}
print_str: {
.label str = 7
b1:
ldy #0
lda (str),y
cmp #'@'
bne b2
rts
b2:
ldy #0
lda (str),y
sta (char_cursor),y
inc char_cursor
bne !+
inc char_cursor+1
!:
inc str
bne !+
inc str+1
!:
jmp b1
}
div8u: {
.label dividend = 9
.label divisor = $c
.label quotient = $a
.label return = $a
ldx #0
txa
sta quotient
tay
b1:
tya
asl
tay
lda #$80
and dividend
cmp #0
beq b2
iny
b2:
asl dividend
asl quotient
cpy divisor
bcc b3
inc quotient
tya
sec
sbc divisor
tay
b3:
inx
cpx #8
bne b1
sty main.rem
rts
}
print_cls: {
.label sc = 3
lda #<$400
sta sc
lda #>$400
sta sc+1
b1:
lda #' '
ldy #0
sta (sc),y
inc sc
bne !+
inc sc+1
!:
lda sc+1
cmp #>$400+$3e8
bne b1
lda sc
cmp #<$400+$3e8
bne b1
rts
}

167
src/test/java/dk/camelot64/kickc/test/ref/division.cfg Normal file
View File

@ -0,0 +1,167 @@
@begin: scope:[] from
[0] phi() [ ] ( )
to:@10
@10: scope:[] from @begin
[1] phi() [ ] ( )
[2] call main param-assignment [ ] ( )
to:@end
@end: scope:[] from @10
[3] phi() [ ] ( )
main: scope:[main] from @10
[4] phi() [ ] ( main:2 [ ] )
[5] call print_cls param-assignment [ ] ( main:2 [ ] )
to:main::@1
main::@1: scope:[main] from main main::@13
[6] (byte*) line_cursor#13 ← phi( main::@13/(byte*) line_cursor#1 main/((byte*))(word/signed word/dword/signed dword) 1024 ) [ main::i#10 char_cursor#42 line_cursor#13 ] ( main:2 [ main::i#10 char_cursor#42 line_cursor#13 ] )
[6] (byte*) char_cursor#42 ← phi( main::@13/(byte*~) char_cursor#48 main/((byte*))(word/signed word/dword/signed dword) 1024 ) [ main::i#10 char_cursor#42 line_cursor#13 ] ( main:2 [ main::i#10 char_cursor#42 line_cursor#13 ] )
[6] (byte) main::i#10 ← phi( main::@13/(byte) main::i#1 main/(byte/signed byte/word/signed word/dword/signed dword) 0 ) [ main::i#10 char_cursor#42 line_cursor#13 ] ( main:2 [ main::i#10 char_cursor#42 line_cursor#13 ] )
[7] (byte) main::dividend#0 ← *((const byte[]) main::dividends#0 + (byte) main::i#10) [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 ] ( main:2 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 ] )
[8] (byte) main::divisor#0 ← *((const byte[]) main::divisors#0 + (byte) main::i#10) [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 ] ( main:2 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 ] )
[9] (byte) div8u::dividend#0 ← (byte) main::dividend#0 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::dividend#0 ] ( main:2 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::dividend#0 ] )
[10] (byte) div8u::divisor#0 ← (byte) main::divisor#0 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::dividend#0 div8u::divisor#0 ] ( main:2 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::dividend#0 div8u::divisor#0 ] )
[11] call div8u param-assignment [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::return#1 ] ( main:2 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::return#1 ] )
[12] (byte) div8u::return#0 ← (byte) div8u::return#1 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::return#0 ] ( main:2 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::return#0 ] )
to:main::@4
main::@4: scope:[main] from main::@1
[13] (byte) main::res#0 ← (byte) div8u::return#0 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 main::res#0 ] ( main:2 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 main::res#0 ] )
[14] (byte) print_byte::b#0 ← (byte) main::dividend#0 [ main::i#10 char_cursor#42 line_cursor#13 main::divisor#0 main::res#0 print_byte::b#0 ] ( main:2 [ main::i#10 char_cursor#42 line_cursor#13 main::divisor#0 main::res#0 print_byte::b#0 ] )
[15] call print_byte param-assignment [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 char_cursor#28 ] ( main:2 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 char_cursor#28 ] )
to:main::@5
main::@5: scope:[main] from main::@4
[16] phi() [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 char_cursor#28 ] ( main:2 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 char_cursor#28 ] )
[17] call print_str param-assignment [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 char_cursor#2 ] ( main:2 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 char_cursor#2 ] )
to:main::@6
main::@6: scope:[main] from main::@5
[18] (byte) print_byte::b#1 ← (byte) main::divisor#0 [ main::i#10 line_cursor#13 main::res#0 print_byte::b#1 char_cursor#2 ] ( main:2 [ main::i#10 line_cursor#13 main::res#0 print_byte::b#1 char_cursor#2 ] )
[19] call print_byte param-assignment [ main::i#10 line_cursor#13 main::res#0 char_cursor#28 ] ( main:2 [ main::i#10 line_cursor#13 main::res#0 char_cursor#28 ] )
to:main::@7
main::@7: scope:[main] from main::@6
[20] phi() [ main::i#10 line_cursor#13 main::res#0 char_cursor#28 ] ( main:2 [ main::i#10 line_cursor#13 main::res#0 char_cursor#28 ] )
[21] call print_str param-assignment [ main::i#10 line_cursor#13 main::res#0 char_cursor#2 ] ( main:2 [ main::i#10 line_cursor#13 main::res#0 char_cursor#2 ] )
to:main::@8
main::@8: scope:[main] from main::@7
[22] (byte) print_byte::b#2 ← (byte) main::res#0 [ main::i#10 line_cursor#13 print_byte::b#2 char_cursor#2 ] ( main:2 [ main::i#10 line_cursor#13 print_byte::b#2 char_cursor#2 ] )
[23] call print_byte param-assignment [ main::i#10 line_cursor#13 char_cursor#28 ] ( main:2 [ main::i#10 line_cursor#13 char_cursor#28 ] )
to:main::@9
main::@9: scope:[main] from main::@8
[24] phi() [ main::i#10 line_cursor#13 char_cursor#28 ] ( main:2 [ main::i#10 line_cursor#13 char_cursor#28 ] )
[25] call print_str param-assignment [ main::i#10 line_cursor#13 char_cursor#2 ] ( main:2 [ main::i#10 line_cursor#13 char_cursor#2 ] )
to:main::@10
main::@10: scope:[main] from main::@9
[26] (byte) print_byte::b#3 ← *((const byte*) main::rem#0) [ main::i#10 line_cursor#13 print_byte::b#3 char_cursor#2 ] ( main:2 [ main::i#10 line_cursor#13 print_byte::b#3 char_cursor#2 ] )
[27] call print_byte param-assignment [ main::i#10 line_cursor#13 char_cursor#28 ] ( main:2 [ main::i#10 line_cursor#13 char_cursor#28 ] )
to:main::@11
main::@11: scope:[main] from main::@10
[28] phi() [ main::i#10 line_cursor#13 char_cursor#28 ] ( main:2 [ main::i#10 line_cursor#13 char_cursor#28 ] )
[29] call print_ln param-assignment [ main::i#10 line_cursor#1 ] ( main:2 [ main::i#10 line_cursor#1 ] )
to:main::@12
main::@12: scope:[main] from main::@11
[30] (byte) main::i#1 ← ++ (byte) main::i#10 [ main::i#1 line_cursor#1 ] ( main:2 [ main::i#1 line_cursor#1 ] )
[31] if((byte) main::i#1!=(byte/signed byte/word/signed word/dword/signed dword) 6) goto main::@13 [ main::i#1 line_cursor#1 ] ( main:2 [ main::i#1 line_cursor#1 ] )
to:main::@return
main::@return: scope:[main] from main::@12
[32] return [ ] ( main:2 [ ] )
to:@return
main::@13: scope:[main] from main::@12
[33] (byte*~) char_cursor#48 ← (byte*) line_cursor#1 [ main::i#1 char_cursor#48 line_cursor#1 ] ( main:2 [ main::i#1 char_cursor#48 line_cursor#1 ] )
to:main::@1
print_ln: scope:[print_ln] from main::@11
[34] phi() [ line_cursor#13 char_cursor#28 ] ( main:2::print_ln:29 [ main::i#10 line_cursor#13 char_cursor#28 ] )
to:print_ln::@1
print_ln::@1: scope:[print_ln] from print_ln print_ln::@1
[35] (byte*) line_cursor#6 ← phi( print_ln/(byte*) line_cursor#13 print_ln::@1/(byte*) line_cursor#1 ) [ line_cursor#6 char_cursor#28 ] ( main:2::print_ln:29 [ main::i#10 line_cursor#6 char_cursor#28 ] )
[36] (byte*) line_cursor#1 ← (byte*) line_cursor#6 + (byte/signed byte/word/signed word/dword/signed dword) 40 [ line_cursor#1 char_cursor#28 ] ( main:2::print_ln:29 [ main::i#10 line_cursor#1 char_cursor#28 ] )
[37] if((byte*) line_cursor#1<(byte*) char_cursor#28) goto print_ln::@1 [ line_cursor#1 char_cursor#28 ] ( main:2::print_ln:29 [ main::i#10 line_cursor#1 char_cursor#28 ] )
to:print_ln::@return
print_ln::@return: scope:[print_ln] from print_ln::@1
[38] return [ line_cursor#1 ] ( main:2::print_ln:29 [ main::i#10 line_cursor#1 ] )
to:@return
print_byte: scope:[print_byte] from main::@10 main::@4 main::@6 main::@8
[39] (byte*) char_cursor#41 ← phi( main::@10/(byte*) char_cursor#2 main::@4/(byte*) char_cursor#42 main::@6/(byte*) char_cursor#2 main::@8/(byte*) char_cursor#2 ) [ print_byte::b#4 char_cursor#41 ] ( main:2::print_byte:15 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 print_byte::b#4 char_cursor#41 ] main:2::print_byte:19 [ main::i#10 line_cursor#13 main::res#0 print_byte::b#4 char_cursor#41 ] main:2::print_byte:23 [ main::i#10 line_cursor#13 print_byte::b#4 char_cursor#41 ] main:2::print_byte:27 [ main::i#10 line_cursor#13 print_byte::b#4 char_cursor#41 ] )
[39] (byte) print_byte::b#4 ← phi( main::@10/(byte) print_byte::b#3 main::@4/(byte) print_byte::b#0 main::@6/(byte) print_byte::b#1 main::@8/(byte) print_byte::b#2 ) [ print_byte::b#4 char_cursor#41 ] ( main:2::print_byte:15 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 print_byte::b#4 char_cursor#41 ] main:2::print_byte:19 [ main::i#10 line_cursor#13 main::res#0 print_byte::b#4 char_cursor#41 ] main:2::print_byte:23 [ main::i#10 line_cursor#13 print_byte::b#4 char_cursor#41 ] main:2::print_byte:27 [ main::i#10 line_cursor#13 print_byte::b#4 char_cursor#41 ] )
[40] (byte~) print_byte::$0 ← (byte) print_byte::b#4 >> (byte/signed byte/word/signed word/dword/signed dword) 4 [ print_byte::b#4 char_cursor#41 print_byte::$0 ] ( main:2::print_byte:15 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 print_byte::b#4 char_cursor#41 print_byte::$0 ] main:2::print_byte:19 [ main::i#10 line_cursor#13 main::res#0 print_byte::b#4 char_cursor#41 print_byte::$0 ] main:2::print_byte:23 [ main::i#10 line_cursor#13 print_byte::b#4 char_cursor#41 print_byte::$0 ] main:2::print_byte:27 [ main::i#10 line_cursor#13 print_byte::b#4 char_cursor#41 print_byte::$0 ] )
[41] (byte) print_char::ch#0 ← *((const string) print_byte::hextab#0 + (byte~) print_byte::$0) [ print_byte::b#4 char_cursor#41 print_char::ch#0 ] ( main:2::print_byte:15 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 print_byte::b#4 char_cursor#41 print_char::ch#0 ] main:2::print_byte:19 [ main::i#10 line_cursor#13 main::res#0 print_byte::b#4 char_cursor#41 print_char::ch#0 ] main:2::print_byte:23 [ main::i#10 line_cursor#13 print_byte::b#4 char_cursor#41 print_char::ch#0 ] main:2::print_byte:27 [ main::i#10 line_cursor#13 print_byte::b#4 char_cursor#41 print_char::ch#0 ] )
[42] call print_char param-assignment [ char_cursor#28 print_byte::b#4 ] ( main:2::print_byte:15 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 char_cursor#28 print_byte::b#4 ] main:2::print_byte:19 [ main::i#10 line_cursor#13 main::res#0 char_cursor#28 print_byte::b#4 ] main:2::print_byte:23 [ main::i#10 line_cursor#13 char_cursor#28 print_byte::b#4 ] main:2::print_byte:27 [ main::i#10 line_cursor#13 char_cursor#28 print_byte::b#4 ] )
to:print_byte::@1
print_byte::@1: scope:[print_byte] from print_byte
[43] (byte~) print_byte::$2 ← (byte) print_byte::b#4 & (byte/signed byte/word/signed word/dword/signed dword) 15 [ char_cursor#28 print_byte::$2 ] ( main:2::print_byte:15 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 char_cursor#28 print_byte::$2 ] main:2::print_byte:19 [ main::i#10 line_cursor#13 main::res#0 char_cursor#28 print_byte::$2 ] main:2::print_byte:23 [ main::i#10 line_cursor#13 char_cursor#28 print_byte::$2 ] main:2::print_byte:27 [ main::i#10 line_cursor#13 char_cursor#28 print_byte::$2 ] )
[44] (byte) print_char::ch#1 ← *((const string) print_byte::hextab#0 + (byte~) print_byte::$2) [ char_cursor#28 print_char::ch#1 ] ( main:2::print_byte:15 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 char_cursor#28 print_char::ch#1 ] main:2::print_byte:19 [ main::i#10 line_cursor#13 main::res#0 char_cursor#28 print_char::ch#1 ] main:2::print_byte:23 [ main::i#10 line_cursor#13 char_cursor#28 print_char::ch#1 ] main:2::print_byte:27 [ main::i#10 line_cursor#13 char_cursor#28 print_char::ch#1 ] )
[45] call print_char param-assignment [ char_cursor#28 ] ( main:2::print_byte:15 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 char_cursor#28 ] main:2::print_byte:19 [ main::i#10 line_cursor#13 main::res#0 char_cursor#28 ] main:2::print_byte:23 [ main::i#10 line_cursor#13 char_cursor#28 ] main:2::print_byte:27 [ main::i#10 line_cursor#13 char_cursor#28 ] )
to:print_byte::@return
print_byte::@return: scope:[print_byte] from print_byte::@1
[46] return [ char_cursor#28 ] ( main:2::print_byte:15 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 char_cursor#28 ] main:2::print_byte:19 [ main::i#10 line_cursor#13 main::res#0 char_cursor#28 ] main:2::print_byte:23 [ main::i#10 line_cursor#13 char_cursor#28 ] main:2::print_byte:27 [ main::i#10 line_cursor#13 char_cursor#28 ] )
to:@return
print_char: scope:[print_char] from print_byte print_byte::@1
[47] (byte*) char_cursor#27 ← phi( print_byte/(byte*) char_cursor#41 print_byte::@1/(byte*) char_cursor#28 ) [ print_char::ch#2 char_cursor#27 ] ( main:2::print_byte:15::print_char:42 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 print_byte::b#4 print_char::ch#2 char_cursor#27 ] main:2::print_byte:19::print_char:42 [ main::i#10 line_cursor#13 main::res#0 print_byte::b#4 print_char::ch#2 char_cursor#27 ] main:2::print_byte:23::print_char:42 [ main::i#10 line_cursor#13 print_byte::b#4 print_char::ch#2 char_cursor#27 ] main:2::print_byte:27::print_char:42 [ main::i#10 line_cursor#13 print_byte::b#4 print_char::ch#2 char_cursor#27 ] main:2::print_byte:15::print_char:45 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 print_char::ch#2 char_cursor#27 ] main:2::print_byte:19::print_char:45 [ main::i#10 line_cursor#13 main::res#0 print_char::ch#2 char_cursor#27 ] main:2::print_byte:23::print_char:45 [ main::i#10 line_cursor#13 print_char::ch#2 char_cursor#27 ] main:2::print_byte:27::print_char:45 [ main::i#10 line_cursor#13 print_char::ch#2 char_cursor#27 ] )
[47] (byte) print_char::ch#2 ← phi( print_byte/(byte) print_char::ch#0 print_byte::@1/(byte) print_char::ch#1 ) [ print_char::ch#2 char_cursor#27 ] ( main:2::print_byte:15::print_char:42 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 print_byte::b#4 print_char::ch#2 char_cursor#27 ] main:2::print_byte:19::print_char:42 [ main::i#10 line_cursor#13 main::res#0 print_byte::b#4 print_char::ch#2 char_cursor#27 ] main:2::print_byte:23::print_char:42 [ main::i#10 line_cursor#13 print_byte::b#4 print_char::ch#2 char_cursor#27 ] main:2::print_byte:27::print_char:42 [ main::i#10 line_cursor#13 print_byte::b#4 print_char::ch#2 char_cursor#27 ] main:2::print_byte:15::print_char:45 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 print_char::ch#2 char_cursor#27 ] main:2::print_byte:19::print_char:45 [ main::i#10 line_cursor#13 main::res#0 print_char::ch#2 char_cursor#27 ] main:2::print_byte:23::print_char:45 [ main::i#10 line_cursor#13 print_char::ch#2 char_cursor#27 ] main:2::print_byte:27::print_char:45 [ main::i#10 line_cursor#13 print_char::ch#2 char_cursor#27 ] )
[48] *((byte*) char_cursor#27) ← (byte) print_char::ch#2 [ char_cursor#27 ] ( main:2::print_byte:15::print_char:42 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 print_byte::b#4 char_cursor#27 ] main:2::print_byte:19::print_char:42 [ main::i#10 line_cursor#13 main::res#0 print_byte::b#4 char_cursor#27 ] main:2::print_byte:23::print_char:42 [ main::i#10 line_cursor#13 print_byte::b#4 char_cursor#27 ] main:2::print_byte:27::print_char:42 [ main::i#10 line_cursor#13 print_byte::b#4 char_cursor#27 ] main:2::print_byte:15::print_char:45 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 char_cursor#27 ] main:2::print_byte:19::print_char:45 [ main::i#10 line_cursor#13 main::res#0 char_cursor#27 ] main:2::print_byte:23::print_char:45 [ main::i#10 line_cursor#13 char_cursor#27 ] main:2::print_byte:27::print_char:45 [ main::i#10 line_cursor#13 char_cursor#27 ] )
[49] (byte*) char_cursor#28 ← ++ (byte*) char_cursor#27 [ char_cursor#28 ] ( main:2::print_byte:15::print_char:42 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 print_byte::b#4 char_cursor#28 ] main:2::print_byte:19::print_char:42 [ main::i#10 line_cursor#13 main::res#0 print_byte::b#4 char_cursor#28 ] main:2::print_byte:23::print_char:42 [ main::i#10 line_cursor#13 print_byte::b#4 char_cursor#28 ] main:2::print_byte:27::print_char:42 [ main::i#10 line_cursor#13 print_byte::b#4 char_cursor#28 ] main:2::print_byte:15::print_char:45 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 char_cursor#28 ] main:2::print_byte:19::print_char:45 [ main::i#10 line_cursor#13 main::res#0 char_cursor#28 ] main:2::print_byte:23::print_char:45 [ main::i#10 line_cursor#13 char_cursor#28 ] main:2::print_byte:27::print_char:45 [ main::i#10 line_cursor#13 char_cursor#28 ] )
to:print_char::@return
print_char::@return: scope:[print_char] from print_char
[50] return [ char_cursor#28 ] ( main:2::print_byte:15::print_char:42 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 print_byte::b#4 char_cursor#28 ] main:2::print_byte:19::print_char:42 [ main::i#10 line_cursor#13 main::res#0 print_byte::b#4 char_cursor#28 ] main:2::print_byte:23::print_char:42 [ main::i#10 line_cursor#13 print_byte::b#4 char_cursor#28 ] main:2::print_byte:27::print_char:42 [ main::i#10 line_cursor#13 print_byte::b#4 char_cursor#28 ] main:2::print_byte:15::print_char:45 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 char_cursor#28 ] main:2::print_byte:19::print_char:45 [ main::i#10 line_cursor#13 main::res#0 char_cursor#28 ] main:2::print_byte:23::print_char:45 [ main::i#10 line_cursor#13 char_cursor#28 ] main:2::print_byte:27::print_char:45 [ main::i#10 line_cursor#13 char_cursor#28 ] )
to:@return
print_str: scope:[print_str] from main::@5 main::@7 main::@9
[51] (byte*) print_str::str#6 ← phi( main::@5/(const string) main::str main::@7/(const string) main::str1 main::@9/(const string) main::str2 ) [ char_cursor#28 print_str::str#6 ] ( main:2::print_str:17 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 char_cursor#28 print_str::str#6 ] main:2::print_str:21 [ main::i#10 line_cursor#13 main::res#0 char_cursor#28 print_str::str#6 ] main:2::print_str:25 [ main::i#10 line_cursor#13 char_cursor#28 print_str::str#6 ] )
to:print_str::@1
print_str::@1: scope:[print_str] from print_str print_str::@2
[52] (byte*) char_cursor#2 ← phi( print_str/(byte*) char_cursor#28 print_str::@2/(byte*) char_cursor#1 ) [ char_cursor#2 print_str::str#4 ] ( main:2::print_str:17 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 char_cursor#2 print_str::str#4 ] main:2::print_str:21 [ main::i#10 line_cursor#13 main::res#0 char_cursor#2 print_str::str#4 ] main:2::print_str:25 [ main::i#10 line_cursor#13 char_cursor#2 print_str::str#4 ] )
[52] (byte*) print_str::str#4 ← phi( print_str/(byte*) print_str::str#6 print_str::@2/(byte*) print_str::str#0 ) [ char_cursor#2 print_str::str#4 ] ( main:2::print_str:17 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 char_cursor#2 print_str::str#4 ] main:2::print_str:21 [ main::i#10 line_cursor#13 main::res#0 char_cursor#2 print_str::str#4 ] main:2::print_str:25 [ main::i#10 line_cursor#13 char_cursor#2 print_str::str#4 ] )
[53] if(*((byte*) print_str::str#4)!=(byte) '@') goto print_str::@2 [ char_cursor#2 print_str::str#4 ] ( main:2::print_str:17 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 char_cursor#2 print_str::str#4 ] main:2::print_str:21 [ main::i#10 line_cursor#13 main::res#0 char_cursor#2 print_str::str#4 ] main:2::print_str:25 [ main::i#10 line_cursor#13 char_cursor#2 print_str::str#4 ] )
to:print_str::@return
print_str::@return: scope:[print_str] from print_str::@1
[54] return [ char_cursor#2 ] ( main:2::print_str:17 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 char_cursor#2 ] main:2::print_str:21 [ main::i#10 line_cursor#13 main::res#0 char_cursor#2 ] main:2::print_str:25 [ main::i#10 line_cursor#13 char_cursor#2 ] )
to:@return
print_str::@2: scope:[print_str] from print_str::@1
[55] *((byte*) char_cursor#2) ← *((byte*) print_str::str#4) [ char_cursor#2 print_str::str#4 ] ( main:2::print_str:17 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 char_cursor#2 print_str::str#4 ] main:2::print_str:21 [ main::i#10 line_cursor#13 main::res#0 char_cursor#2 print_str::str#4 ] main:2::print_str:25 [ main::i#10 line_cursor#13 char_cursor#2 print_str::str#4 ] )
[56] (byte*) char_cursor#1 ← ++ (byte*) char_cursor#2 [ print_str::str#4 char_cursor#1 ] ( main:2::print_str:17 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 print_str::str#4 char_cursor#1 ] main:2::print_str:21 [ main::i#10 line_cursor#13 main::res#0 print_str::str#4 char_cursor#1 ] main:2::print_str:25 [ main::i#10 line_cursor#13 print_str::str#4 char_cursor#1 ] )
[57] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#4 [ print_str::str#0 char_cursor#1 ] ( main:2::print_str:17 [ main::i#10 line_cursor#13 main::divisor#0 main::res#0 print_str::str#0 char_cursor#1 ] main:2::print_str:21 [ main::i#10 line_cursor#13 main::res#0 print_str::str#0 char_cursor#1 ] main:2::print_str:25 [ main::i#10 line_cursor#13 print_str::str#0 char_cursor#1 ] )
to:print_str::@1
div8u: scope:[div8u] from main::@1
[58] phi() [ div8u::dividend#0 div8u::divisor#0 ] ( main:2::div8u:11 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::dividend#0 div8u::divisor#0 ] )
to:div8u::@1
div8u::@1: scope:[div8u] from div8u div8u::@3
[59] (byte) div8u::i#2 ← phi( div8u/(byte/signed byte/word/signed word/dword/signed dword) 0 div8u::@3/(byte) div8u::i#1 ) [ div8u::divisor#0 div8u::rem#4 div8u::dividend#2 div8u::quotient#3 div8u::i#2 ] ( main:2::div8u:11 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::divisor#0 div8u::rem#4 div8u::dividend#2 div8u::quotient#3 div8u::i#2 ] )
[59] (byte) div8u::quotient#3 ← phi( div8u/(byte/signed byte/word/signed word/dword/signed dword) 0 div8u::@3/(byte) div8u::return#1 ) [ div8u::divisor#0 div8u::rem#4 div8u::dividend#2 div8u::quotient#3 div8u::i#2 ] ( main:2::div8u:11 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::divisor#0 div8u::rem#4 div8u::dividend#2 div8u::quotient#3 div8u::i#2 ] )
[59] (byte) div8u::dividend#2 ← phi( div8u/(byte) div8u::dividend#0 div8u::@3/(byte) div8u::dividend#1 ) [ div8u::divisor#0 div8u::rem#4 div8u::dividend#2 div8u::quotient#3 div8u::i#2 ] ( main:2::div8u:11 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::divisor#0 div8u::rem#4 div8u::dividend#2 div8u::quotient#3 div8u::i#2 ] )
[59] (byte) div8u::rem#4 ← phi( div8u/(byte/signed byte/word/signed word/dword/signed dword) 0 div8u::@3/(byte) div8u::rem#8 ) [ div8u::divisor#0 div8u::rem#4 div8u::dividend#2 div8u::quotient#3 div8u::i#2 ] ( main:2::div8u:11 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::divisor#0 div8u::rem#4 div8u::dividend#2 div8u::quotient#3 div8u::i#2 ] )
[60] (byte) div8u::rem#1 ← (byte) div8u::rem#4 << (byte/signed byte/word/signed word/dword/signed dword) 1 [ div8u::divisor#0 div8u::dividend#2 div8u::quotient#3 div8u::i#2 div8u::rem#1 ] ( main:2::div8u:11 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::divisor#0 div8u::dividend#2 div8u::quotient#3 div8u::i#2 div8u::rem#1 ] )
[61] (byte~) div8u::$1 ← (byte) div8u::dividend#2 & (byte/word/signed word/dword/signed dword) 128 [ div8u::divisor#0 div8u::dividend#2 div8u::quotient#3 div8u::i#2 div8u::rem#1 div8u::$1 ] ( main:2::div8u:11 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::divisor#0 div8u::dividend#2 div8u::quotient#3 div8u::i#2 div8u::rem#1 div8u::$1 ] )
[62] if((byte~) div8u::$1==(byte/signed byte/word/signed word/dword/signed dword) 0) goto div8u::@2 [ div8u::divisor#0 div8u::dividend#2 div8u::quotient#3 div8u::i#2 div8u::rem#1 ] ( main:2::div8u:11 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::divisor#0 div8u::dividend#2 div8u::quotient#3 div8u::i#2 div8u::rem#1 ] )
to:div8u::@4
div8u::@4: scope:[div8u] from div8u::@1
[63] (byte) div8u::rem#2 ← ++ (byte) div8u::rem#1 [ div8u::divisor#0 div8u::dividend#2 div8u::quotient#3 div8u::i#2 div8u::rem#2 ] ( main:2::div8u:11 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::divisor#0 div8u::dividend#2 div8u::quotient#3 div8u::i#2 div8u::rem#2 ] )
to:div8u::@2
div8u::@2: scope:[div8u] from div8u::@1 div8u::@4
[64] (byte) div8u::rem#5 ← phi( div8u::@1/(byte) div8u::rem#1 div8u::@4/(byte) div8u::rem#2 ) [ div8u::divisor#0 div8u::dividend#2 div8u::quotient#3 div8u::i#2 div8u::rem#5 ] ( main:2::div8u:11 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::divisor#0 div8u::dividend#2 div8u::quotient#3 div8u::i#2 div8u::rem#5 ] )
[65] (byte) div8u::dividend#1 ← (byte) div8u::dividend#2 << (byte/signed byte/word/signed word/dword/signed dword) 1 [ div8u::divisor#0 div8u::quotient#3 div8u::i#2 div8u::dividend#1 div8u::rem#5 ] ( main:2::div8u:11 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::divisor#0 div8u::quotient#3 div8u::i#2 div8u::dividend#1 div8u::rem#5 ] )
[66] (byte) div8u::quotient#1 ← (byte) div8u::quotient#3 << (byte/signed byte/word/signed word/dword/signed dword) 1 [ div8u::divisor#0 div8u::i#2 div8u::dividend#1 div8u::rem#5 div8u::quotient#1 ] ( main:2::div8u:11 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::divisor#0 div8u::i#2 div8u::dividend#1 div8u::rem#5 div8u::quotient#1 ] )
[67] if((byte) div8u::rem#5<(byte) div8u::divisor#0) goto div8u::@3 [ div8u::divisor#0 div8u::i#2 div8u::dividend#1 div8u::rem#5 div8u::quotient#1 ] ( main:2::div8u:11 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::divisor#0 div8u::i#2 div8u::dividend#1 div8u::rem#5 div8u::quotient#1 ] )
to:div8u::@5
div8u::@5: scope:[div8u] from div8u::@2
[68] (byte) div8u::quotient#2 ← ++ (byte) div8u::quotient#1 [ div8u::divisor#0 div8u::i#2 div8u::dividend#1 div8u::rem#5 div8u::quotient#2 ] ( main:2::div8u:11 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::divisor#0 div8u::i#2 div8u::dividend#1 div8u::rem#5 div8u::quotient#2 ] )
[69] (byte) div8u::rem#3 ← (byte) div8u::rem#5 - (byte) div8u::divisor#0 [ div8u::divisor#0 div8u::i#2 div8u::dividend#1 div8u::quotient#2 div8u::rem#3 ] ( main:2::div8u:11 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::divisor#0 div8u::i#2 div8u::dividend#1 div8u::quotient#2 div8u::rem#3 ] )
to:div8u::@3
div8u::@3: scope:[div8u] from div8u::@2 div8u::@5
[70] (byte) div8u::return#1 ← phi( div8u::@2/(byte) div8u::quotient#1 div8u::@5/(byte) div8u::quotient#2 ) [ div8u::divisor#0 div8u::return#1 div8u::i#2 div8u::rem#8 div8u::dividend#1 ] ( main:2::div8u:11 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::divisor#0 div8u::return#1 div8u::i#2 div8u::rem#8 div8u::dividend#1 ] )
[70] (byte) div8u::rem#8 ← phi( div8u::@2/(byte) div8u::rem#5 div8u::@5/(byte) div8u::rem#3 ) [ div8u::divisor#0 div8u::return#1 div8u::i#2 div8u::rem#8 div8u::dividend#1 ] ( main:2::div8u:11 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::divisor#0 div8u::return#1 div8u::i#2 div8u::rem#8 div8u::dividend#1 ] )
[71] (byte) div8u::i#1 ← ++ (byte) div8u::i#2 [ div8u::divisor#0 div8u::return#1 div8u::rem#8 div8u::dividend#1 div8u::i#1 ] ( main:2::div8u:11 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::divisor#0 div8u::return#1 div8u::rem#8 div8u::dividend#1 div8u::i#1 ] )
[72] if((byte) div8u::i#1!=(byte/signed byte/word/signed word/dword/signed dword) 8) goto div8u::@1 [ div8u::divisor#0 div8u::return#1 div8u::rem#8 div8u::dividend#1 div8u::i#1 ] ( main:2::div8u:11 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::divisor#0 div8u::return#1 div8u::rem#8 div8u::dividend#1 div8u::i#1 ] )
to:div8u::@6
div8u::@6: scope:[div8u] from div8u::@3
[73] *((const byte*) main::rem#0) ← (byte) div8u::rem#8 [ div8u::return#1 ] ( main:2::div8u:11 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::return#1 ] )
to:div8u::@return
div8u::@return: scope:[div8u] from div8u::@6
[74] return [ div8u::return#1 ] ( main:2::div8u:11 [ main::i#10 char_cursor#42 line_cursor#13 main::dividend#0 main::divisor#0 div8u::return#1 ] )
to:@return
print_cls: scope:[print_cls] from main
[75] phi() [ ] ( main:2::print_cls:5 [ ] )
to:print_cls::@1
print_cls::@1: scope:[print_cls] from print_cls print_cls::@1
[76] (byte*) print_cls::sc#2 ← phi( print_cls/((byte*))(word/signed word/dword/signed dword) 1024 print_cls::@1/(byte*) print_cls::sc#1 ) [ print_cls::sc#2 ] ( main:2::print_cls:5 [ print_cls::sc#2 ] )
[77] *((byte*) print_cls::sc#2) ← (byte) ' ' [ print_cls::sc#2 ] ( main:2::print_cls:5 [ print_cls::sc#2 ] )
[78] (byte*) print_cls::sc#1 ← ++ (byte*) print_cls::sc#2 [ print_cls::sc#1 ] ( main:2::print_cls:5 [ print_cls::sc#1 ] )
[79] if((byte*) print_cls::sc#1!=(word/signed word/dword/signed dword) 1024+(word/signed word/dword/signed dword) 1000) goto print_cls::@1 [ print_cls::sc#1 ] ( main:2::print_cls:5 [ print_cls::sc#1 ] )
to:print_cls::@return
print_cls::@return: scope:[print_cls] from print_cls::@1
[80] return [ ] ( main:2::print_cls:5 [ ] )
to:@return

3711
src/test/java/dk/camelot64/kickc/test/ref/division.log Normal file
View File

File diff suppressed because it is too large Load Diff

132
src/test/java/dk/camelot64/kickc/test/ref/division.sym Normal file
View File

@ -0,0 +1,132 @@
(label) @10
(label) @begin
(label) @end
(byte*) char_cursor
(byte*) char_cursor#1 char_cursor zp ZP_WORD:5 101.0
(byte*) char_cursor#2 char_cursor zp ZP_WORD:5 33.8
(byte*) char_cursor#27 char_cursor zp ZP_WORD:5 4.0
(byte*) char_cursor#28 char_cursor zp ZP_WORD:5 5.349999999999999
(byte*) char_cursor#41 char_cursor zp ZP_WORD:5 15.333333333333332
(byte*) char_cursor#42 char_cursor zp ZP_WORD:5 2.4444444444444446
(byte*~) char_cursor#48 char_cursor zp ZP_WORD:5 22.0
(byte()) div8u((byte) div8u::dividend , (byte) div8u::divisor , (byte*) div8u::remainder)
(byte~) div8u::$1 reg byte a 202.0
(label) div8u::@1
(label) div8u::@2
(label) div8u::@3
(label) div8u::@4
(label) div8u::@5
(label) div8u::@6
(label) div8u::@return
(byte) div8u::dividend
(byte) div8u::dividend#0 dividend zp ZP_BYTE:9 4.333333333333333
(byte) div8u::dividend#1 dividend zp ZP_BYTE:9 25.25
(byte) div8u::dividend#2 dividend zp ZP_BYTE:9 50.83333333333333
(byte) div8u::divisor
(byte) div8u::divisor#0 divisor zp ZP_BYTE:12 13.3125
(byte) div8u::i
(byte) div8u::i#1 reg byte x 151.5
(byte) div8u::i#2 reg byte x 16.833333333333332
(byte) div8u::quotient
(byte) div8u::quotient#1 quotient zp ZP_BYTE:10 151.5
(byte) div8u::quotient#2 quotient zp ZP_BYTE:10 101.0
(byte) div8u::quotient#3 quotient zp ZP_BYTE:10 28.857142857142858
(byte) div8u::rem
(byte) div8u::rem#1 reg byte y 101.0
(byte) div8u::rem#2 reg byte y 202.0
(byte) div8u::rem#3 reg byte y 202.0
(byte) div8u::rem#4 reg byte y 202.0
(byte) div8u::rem#5 reg byte y 101.0
(byte) div8u::rem#8 reg byte y 101.66666666666667
(byte*) div8u::remainder
(byte) div8u::return
(byte) div8u::return#0 reg byte a 22.0
(byte) div8u::return#1 return zp ZP_BYTE:10 52.33333333333333
(byte*) line_cursor
(byte*) line_cursor#1 line_cursor zp ZP_WORD:3 46.42857142857143
(byte*) line_cursor#13 line_cursor zp ZP_WORD:3 0.5416666666666666
(byte*) line_cursor#6 line_cursor zp ZP_WORD:3 204.0
(void()) main()
(label) main::@1
(label) main::@10
(label) main::@11
(label) main::@12
(label) main::@13
(label) main::@4
(label) main::@5
(label) main::@6
(label) main::@7
(label) main::@8
(label) main::@9
(label) main::@return
(byte) main::dividend
(byte) main::dividend#0 dividend zp ZP_BYTE:11 4.714285714285714
(byte[]) main::dividends
(const byte[]) main::dividends#0 dividends = { (byte/word/signed word/dword/signed dword) 255, (byte/word/signed word/dword/signed dword) 255, (byte/word/signed word/dword/signed dword) 255, (byte/word/signed word/dword/signed dword) 255, (byte/word/signed word/dword/signed dword) 255, (byte/word/signed word/dword/signed dword) 255 }
(byte) main::divisor
(byte) main::divisor#0 divisor zp ZP_BYTE:12 3.3000000000000003
(byte[]) main::divisors
(const byte[]) main::divisors#0 divisors = { (byte/signed byte/word/signed word/dword/signed dword) 5, (byte/signed byte/word/signed word/dword/signed dword) 7, (byte/signed byte/word/signed word/dword/signed dword) 11, (byte/signed byte/word/signed word/dword/signed dword) 13, (byte/signed byte/word/signed word/dword/signed dword) 17, (byte/signed byte/word/signed word/dword/signed dword) 19 }
(byte) main::i
(byte) main::i#1 i zp ZP_BYTE:2 11.0
(byte) main::i#10 i zp ZP_BYTE:2 1.8333333333333333
(byte*) main::rem
(const byte*) main::rem#0 rem = ((byte*))(byte/word/signed word/dword/signed dword) 255
(byte) main::res
(byte) main::res#0 res zp ZP_BYTE:9 2.4444444444444446
(const string) main::str str = (string) " / @"
(const string) main::str1 str1 = (string) " = @"
(const string) main::str2 str2 = (string) " @"
(void()) print_byte((byte) print_byte::b)
(byte~) print_byte::$0 reg byte a 4.0
(byte~) print_byte::$2 reg byte a 4.0
(label) print_byte::@1
(label) print_byte::@return
(byte) print_byte::b
(byte) print_byte::b#0 reg byte x 22.0
(byte) print_byte::b#1 reg byte x 22.0
(byte) print_byte::b#2 reg byte x 22.0
(byte) print_byte::b#3 reg byte x 22.0
(byte) print_byte::b#4 reg byte x 12.0
(byte[]) print_byte::hextab
(const string) print_byte::hextab#0 hextab = (string) "0123456789abcdef"
(void()) print_char((byte) print_char::ch)
(label) print_char::@return
(byte) print_char::ch
(byte) print_char::ch#0 reg byte a 4.0
(byte) print_char::ch#1 reg byte a 4.0
(byte) print_char::ch#2 reg byte a 6.0
(void()) print_cls()
(label) print_cls::@1
(label) print_cls::@return
(byte*) print_cls::sc
(byte*) print_cls::sc#1 sc zp ZP_WORD:3 16.5
(byte*) print_cls::sc#2 sc zp ZP_WORD:3 16.5
(void()) print_ln()
(label) print_ln::@1
(label) print_ln::@return
(void()) print_str((byte*) print_str::str)
(label) print_str::@1
(label) print_str::@2
(label) print_str::@return
(byte*) print_str::str
(byte*) print_str::str#0 str zp ZP_WORD:7 202.0
(byte*) print_str::str#4 str zp ZP_WORD:7 101.5
(byte*) print_str::str#6 str zp ZP_WORD:7 2.0
zp ZP_BYTE:2 [ main::i#10 main::i#1 ]
zp ZP_WORD:3 [ line_cursor#6 line_cursor#13 line_cursor#1 print_cls::sc#2 print_cls::sc#1 ]
reg byte x [ print_byte::b#4 print_byte::b#3 print_byte::b#0 print_byte::b#1 print_byte::b#2 ]
reg byte a [ print_char::ch#2 print_char::ch#0 print_char::ch#1 ]
zp ZP_WORD:5 [ char_cursor#27 char_cursor#41 char_cursor#2 char_cursor#42 char_cursor#48 char_cursor#28 char_cursor#1 ]
zp ZP_WORD:7 [ print_str::str#4 print_str::str#6 print_str::str#0 ]
reg byte y [ div8u::rem#4 div8u::rem#8 div8u::rem#5 div8u::rem#1 div8u::rem#2 div8u::rem#3 ]
zp ZP_BYTE:9 [ div8u::dividend#2 div8u::dividend#0 div8u::dividend#1 main::res#0 ]
zp ZP_BYTE:10 [ div8u::quotient#3 div8u::return#1 div8u::quotient#1 div8u::quotient#2 ]
reg byte x [ div8u::i#2 div8u::i#1 ]
zp ZP_BYTE:11 [ main::dividend#0 ]
zp ZP_BYTE:12 [ main::divisor#0 div8u::divisor#0 ]
reg byte a [ div8u::return#0 ]
reg byte a [ print_byte::$0 ]
reg byte a [ print_byte::$2 ]
reg byte a [ div8u::$1 ]

2
src/test/java/dk/camelot64/kickc/test/ref/double-import.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const BGCOL = $d021
.label BGCOL = $d021
.const RED = 2
jsr main
main: {

6
src/test/java/dk/camelot64/kickc/test/ref/double-import.log
View File

@ -148,7 +148,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const BGCOL = $d021
.label BGCOL = $d021
.const RED = 2
//SEG2 @begin
bbegin:
@ -192,7 +192,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const BGCOL = $d021
.label BGCOL = $d021
.const RED = 2
//SEG2 @begin
bbegin:
@ -255,7 +255,7 @@ Score: 18
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const BGCOL = $d021
.label BGCOL = $d021
.const RED = 2
//SEG2 @begin
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]

2
src/test/java/dk/camelot64/kickc/test/ref/dword.asm
View File

@ -4,7 +4,7 @@
jsr main
main: {
.const a = $ee6b2800
.const SCREEN = $400
.label SCREEN = $400
.label b = 2
ldx #0
b1:

6
src/test/java/dk/camelot64/kickc/test/ref/dword.log
View File

@ -277,7 +277,7 @@ bend:
//SEG9 main
main: {
.const a = $ee6b2800
.const SCREEN = $400
.label SCREEN = $400
.label b = 3
.label c = 7
.label i = 2
@ -370,7 +370,7 @@ bend:
//SEG9 main
main: {
.const a = $ee6b2800
.const SCREEN = $400
.label SCREEN = $400
.label b = 2
//SEG10 [5] phi from main to main::@1 [phi:main->main::@1]
b1_from_main:
@ -477,7 +477,7 @@ Score: 477
//SEG9 main
main: {
.const a = $ee6b2800
.const SCREEN = $400
.label SCREEN = $400
.label b = 2
//SEG10 [5] phi from main to main::@1 [phi:main->main::@1]
//SEG11 [5] phi (byte) main::i#2 = (byte/signed byte/word/signed word/dword/signed dword) 0 [phi:main->main::@1#0] -- vbuxx=vbuc1

2
src/test/java/dk/camelot64/kickc/test/ref/fibmem.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const fibs = $1100
.label fibs = $1100
jsr main
main: {
lda #0

6
src/test/java/dk/camelot64/kickc/test/ref/fibmem.log
View File

@ -237,7 +237,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const fibs = $1100
.label fibs = $1100
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -321,7 +321,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const fibs = $1100
.label fibs = $1100
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -419,7 +419,7 @@ Score: 269
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const fibs = $1100
.label fibs = $1100
//SEG2 @begin
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
//SEG4 @1

8
src/test/java/dk/camelot64/kickc/test/ref/fillscreen.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.label SCREEN = $400
jsr main
main: {
lda SCREEN
@ -9,9 +9,9 @@ main: {
rts
}
fillscreen: {
.const SCREEN2 = SCREEN+$100
.const SCREEN3 = SCREEN+$200
.const SCREEN4 = SCREEN+$3e8
.label SCREEN2 = SCREEN+$100
.label SCREEN3 = SCREEN+$200
.label SCREEN4 = SCREEN+$3e8
ldx #0
b1:
sta SCREEN,x

24
src/test/java/dk/camelot64/kickc/test/ref/fillscreen.log
View File

@ -366,7 +366,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @2 [phi:@begin->@2]
@ -402,9 +402,9 @@ main: {
}
//SEG15 fillscreen
fillscreen: {
.const SCREEN2 = SCREEN+$100
.const SCREEN3 = SCREEN+$200
.const SCREEN4 = SCREEN+$3e8
.label SCREEN2 = SCREEN+$100
.label SCREEN3 = SCREEN+$200
.label SCREEN4 = SCREEN+$3e8
.label c = 4
.label j = 2
//SEG16 [9] phi from fillscreen to fillscreen::@1 [phi:fillscreen->fillscreen::@1]
@ -467,7 +467,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @2 [phi:@begin->@2]
@ -500,9 +500,9 @@ main: {
}
//SEG15 fillscreen
fillscreen: {
.const SCREEN2 = SCREEN+$100
.const SCREEN3 = SCREEN+$200
.const SCREEN4 = SCREEN+$3e8
.label SCREEN2 = SCREEN+$100
.label SCREEN3 = SCREEN+$200
.label SCREEN4 = SCREEN+$3e8
//SEG16 [9] phi from fillscreen to fillscreen::@1 [phi:fillscreen->fillscreen::@1]
b1_from_fillscreen:
//SEG17 [9] phi (byte) fillscreen::j#2 = (byte/signed byte/word/signed word/dword/signed dword) 0 [phi:fillscreen->fillscreen::@1#0] -- vbuxx=vbuc1
@ -595,7 +595,7 @@ Score: 313
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @2 [phi:@begin->@2]
//SEG4 @2
@ -618,9 +618,9 @@ main: {
}
//SEG15 fillscreen
fillscreen: {
.const SCREEN2 = SCREEN+$100
.const SCREEN3 = SCREEN+$200
.const SCREEN4 = SCREEN+$3e8
.label SCREEN2 = SCREEN+$100
.label SCREEN3 = SCREEN+$200
.label SCREEN4 = SCREEN+$3e8
//SEG16 [9] phi from fillscreen to fillscreen::@1 [phi:fillscreen->fillscreen::@1]
//SEG17 [9] phi (byte) fillscreen::j#2 = (byte/signed byte/word/signed word/dword/signed dword) 0 [phi:fillscreen->fillscreen::@1#0] -- vbuxx=vbuc1
ldx #0

4
src/test/java/dk/camelot64/kickc/test/ref/flipper-rex2.asm
View File

@ -1,8 +1,8 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const RASTER = $d012
.const SCREEN = $400
.label RASTER = $d012
.label SCREEN = $400
jsr main
main: {
jsr prepare

12
src/test/java/dk/camelot64/kickc/test/ref/flipper-rex2.log
View File

@ -1173,8 +1173,8 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const RASTER = $d012
.const SCREEN = $400
.label RASTER = $d012
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @4 [phi:@begin->@4]
@ -1534,8 +1534,8 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const RASTER = $d012
.const SCREEN = $400
.label RASTER = $d012
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @4 [phi:@begin->@4]
@ -1987,8 +1987,8 @@ Score: 84327
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const RASTER = $d012
.const SCREEN = $400
.label RASTER = $d012
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @4 [phi:@begin->@4]
//SEG4 @4

2
src/test/java/dk/camelot64/kickc/test/ref/forclassicmin.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.label SCREEN = $400
jsr main
main: {
ldx #0

6
src/test/java/dk/camelot64/kickc/test/ref/forclassicmin.log
View File

@ -226,7 +226,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -291,7 +291,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -381,7 +381,7 @@ Score: 167
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
//SEG4 @1

2
src/test/java/dk/camelot64/kickc/test/ref/forincrementassign.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.label SCREEN = $400
jsr main
main: {
lda #0

6
src/test/java/dk/camelot64/kickc/test/ref/forincrementassign.log
View File

@ -226,7 +226,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -295,7 +295,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -386,7 +386,7 @@ Score: 187
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
//SEG4 @1

4
src/test/java/dk/camelot64/kickc/test/ref/forrangemin.asm
View File

@ -1,8 +1,8 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN1 = $400
.const SCREEN2 = $500
.label SCREEN1 = $400
.label SCREEN2 = $500
jsr main
main: {
ldx #0

12
src/test/java/dk/camelot64/kickc/test/ref/forrangemin.log
View File

@ -324,8 +324,8 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN1 = $400
.const SCREEN2 = $500
.label SCREEN1 = $400
.label SCREEN2 = $500
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -413,8 +413,8 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN1 = $400
.const SCREEN2 = $500
.label SCREEN1 = $400
.label SCREEN2 = $500
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -535,8 +535,8 @@ Score: 322
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN1 = $400
.const SCREEN2 = $500
.label SCREEN1 = $400
.label SCREEN2 = $500
//SEG2 @begin
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
//SEG4 @1

10
src/test/java/dk/camelot64/kickc/test/ref/halfscii.asm
View File

@ -1,11 +1,11 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.const CHARGEN = $d000
.const PROCPORT = 1
.const D018 = $d018
.const CHARSET4 = $2800
.label SCREEN = $400
.label CHARGEN = $d000
.label PROCPORT = 1
.label D018 = $d018
.label CHARSET4 = $2800
jsr main
main: {
.label _1 = 8

30
src/test/java/dk/camelot64/kickc/test/ref/halfscii.log
View File

@ -1315,11 +1315,11 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.const CHARGEN = $d000
.const PROCPORT = 1
.const D018 = $d018
.const CHARSET4 = $2800
.label SCREEN = $400
.label CHARGEN = $d000
.label PROCPORT = 1
.label D018 = $d018
.label CHARSET4 = $2800
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -1832,11 +1832,11 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.const CHARGEN = $d000
.const PROCPORT = 1
.const D018 = $d018
.const CHARSET4 = $2800
.label SCREEN = $400
.label CHARGEN = $d000
.label PROCPORT = 1
.label D018 = $d018
.label CHARSET4 = $2800
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -2293,11 +2293,11 @@ Score: 3054
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.const CHARGEN = $d000
.const PROCPORT = 1
.const D018 = $d018
.const CHARSET4 = $2800
.label SCREEN = $400
.label CHARGEN = $d000
.label PROCPORT = 1
.label D018 = $d018
.label CHARSET4 = $2800
//SEG2 @begin
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
//SEG4 @1

2
src/test/java/dk/camelot64/kickc/test/ref/ifmin.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.label SCREEN = $400
jsr main
main: {
ldx #0

6
src/test/java/dk/camelot64/kickc/test/ref/ifmin.log
View File

@ -269,7 +269,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -343,7 +343,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -446,7 +446,7 @@ Score: 182
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
//SEG4 @1

4
src/test/java/dk/camelot64/kickc/test/ref/importing.asm
View File

@ -1,11 +1,11 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const BGCOL = $d021
.label BGCOL = $d021
.const RED = 2
jsr main
main: {
.const screen = $400
.label screen = $400
lda #1
sta screen
lda #RED

12
src/test/java/dk/camelot64/kickc/test/ref/importing.log
View File

@ -161,7 +161,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const BGCOL = $d021
.label BGCOL = $d021
.const RED = 2
//SEG2 @begin
bbegin:
@ -179,7 +179,7 @@ bend_from_b1:
bend:
//SEG8 main
main: {
.const screen = $400
.label screen = $400
//SEG9 [4] *((const byte*) main::screen#0) ← (byte/signed byte/word/signed word/dword/signed dword) 1 [ ] ( main:2 [ ] ) -- _deref_pbuc1=vbuc2
lda #1
sta screen
@ -210,7 +210,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const BGCOL = $d021
.label BGCOL = $d021
.const RED = 2
//SEG2 @begin
bbegin:
@ -228,7 +228,7 @@ bend_from_b1:
bend:
//SEG8 main
main: {
.const screen = $400
.label screen = $400
//SEG9 [4] *((const byte*) main::screen#0) ← (byte/signed byte/word/signed word/dword/signed dword) 1 [ ] ( main:2 [ ] ) -- _deref_pbuc1=vbuc2
lda #1
sta screen
@ -279,7 +279,7 @@ Score: 24
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const BGCOL = $d021
.label BGCOL = $d021
.const RED = 2
//SEG2 @begin
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -290,7 +290,7 @@ Score: 24
//SEG7 @end
//SEG8 main
main: {
.const screen = $400
.label screen = $400
//SEG9 [4] *((const byte*) main::screen#0) ← (byte/signed byte/word/signed word/dword/signed dword) 1 [ ] ( main:2 [ ] ) -- _deref_pbuc1=vbuc2
lda #1
sta screen

2
src/test/java/dk/camelot64/kickc/test/ref/incd020.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const BGCOL = $d020
.label BGCOL = $d020
jsr main
main: {
b1:

6
src/test/java/dk/camelot64/kickc/test/ref/incd020.log
View File

@ -186,7 +186,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const BGCOL = $d020
.label BGCOL = $d020
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -236,7 +236,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const BGCOL = $d020
.label BGCOL = $d020
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -309,7 +309,7 @@ Score: 156
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const BGCOL = $d020
.label BGCOL = $d020
//SEG2 @begin
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
//SEG4 @1

2
src/test/java/dk/camelot64/kickc/test/ref/inline-assignment.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.label SCREEN = $400
jsr main
main: {
ldx #0

6
src/test/java/dk/camelot64/kickc/test/ref/inline-assignment.log
View File

@ -223,7 +223,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -293,7 +293,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -387,7 +387,7 @@ Score: 237
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
//SEG4 @1

2
src/test/java/dk/camelot64/kickc/test/ref/inline-word.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.label SCREEN = $400
jsr main
main: {
.label w = 3

6
src/test/java/dk/camelot64/kickc/test/ref/inline-word.log
View File

@ -356,7 +356,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -464,7 +464,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -603,7 +603,7 @@ Score: 3387
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
//SEG4 @1

4
src/test/java/dk/camelot64/kickc/test/ref/inlinearrayproblem.asm
View File

@ -1,8 +1,8 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.const SCREEN2 = $400+$28
.label SCREEN = $400
.label SCREEN2 = $400+$28
jsr main
main: {
ldx #0

12
src/test/java/dk/camelot64/kickc/test/ref/inlinearrayproblem.log
View File

@ -272,8 +272,8 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.const SCREEN2 = $400+$28
.label SCREEN = $400
.label SCREEN2 = $400+$28
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -349,8 +349,8 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.const SCREEN2 = $400+$28
.label SCREEN = $400
.label SCREEN2 = $400+$28
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -451,8 +451,8 @@ Score: 287
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.const SCREEN2 = $400+$28
.label SCREEN = $400
.label SCREEN2 = $400+$28
//SEG2 @begin
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
//SEG4 @1

4
src/test/java/dk/camelot64/kickc/test/ref/inmem-const-array.asm
View File

@ -6,8 +6,8 @@
.const GREEN = 5
jsr main
main: {
.const screen = $400
.const cols = $d800
.label screen = $400
.label cols = $d800
ldy #0
ldx #0
b1:

12
src/test/java/dk/camelot64/kickc/test/ref/inmem-const-array.log
View File

@ -423,8 +423,8 @@ bend_from_b1:
bend:
//SEG9 main
main: {
.const screen = $400
.const cols = $d800
.label screen = $400
.label cols = $d800
.label j = 3
.label i = 2
//SEG10 [5] phi from main to main::@1 [phi:main->main::@1]
@ -533,8 +533,8 @@ bend_from_b1:
bend:
//SEG9 main
main: {
.const screen = $400
.const cols = $d800
.label screen = $400
.label cols = $d800
//SEG10 [5] phi from main to main::@1 [phi:main->main::@1]
b1_from_main:
//SEG11 [5] phi (byte) main::j#3 = (byte/signed byte/word/signed word/dword/signed dword) 0 [phi:main->main::@1#0] -- vbuyy=vbuc1
@ -676,8 +676,8 @@ Score: 367
//SEG8 @end
//SEG9 main
main: {
.const screen = $400
.const cols = $d800
.label screen = $400
.label cols = $d800
//SEG10 [5] phi from main to main::@1 [phi:main->main::@1]
//SEG11 [5] phi (byte) main::j#3 = (byte/signed byte/word/signed word/dword/signed dword) 0 [phi:main->main::@1#0] -- vbuyy=vbuc1
ldy #0

2
src/test/java/dk/camelot64/kickc/test/ref/inmemarray.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.label SCREEN = $400
jsr main
main: {
ldx #0

6
src/test/java/dk/camelot64/kickc/test/ref/inmemarray.log
View File

@ -331,7 +331,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -431,7 +431,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -567,7 +567,7 @@ Score: 297
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
//SEG4 @1

2
src/test/java/dk/camelot64/kickc/test/ref/inmemstring.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.label SCREEN = $400
jsr main
main: {
.label cursor = 2

6
src/test/java/dk/camelot64/kickc/test/ref/inmemstring.log
View File

@ -346,7 +346,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -459,7 +459,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
@ -610,7 +610,7 @@ Score: 642
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @1 [phi:@begin->@1]
//SEG4 @1

2
src/test/java/dk/camelot64/kickc/test/ref/iterarray.asm
View File

@ -3,7 +3,7 @@
.pc = $80d "Program"
jsr main
main: {
.const buf = $1100
.label buf = $1100
ldx #5
b1:
txa

6
src/test/java/dk/camelot64/kickc/test/ref/iterarray.log
View File

@ -253,7 +253,7 @@ bend_from_b1:
bend:
//SEG9 main
main: {
.const buf = $1100
.label buf = $1100
.label _1 = 3
.label i = 2
//SEG10 [5] phi from main to main::@1 [phi:main->main::@1]
@ -328,7 +328,7 @@ bend_from_b1:
bend:
//SEG9 main
main: {
.const buf = $1100
.label buf = $1100
//SEG10 [5] phi from main to main::@1 [phi:main->main::@1]
b1_from_main:
//SEG11 [5] phi (byte) main::i#2 = (byte/signed byte/word/signed word/dword/signed dword) 5 [phi:main->main::@1#0] -- vbuxx=vbuc1
@ -415,7 +415,7 @@ Score: 207
//SEG8 @end
//SEG9 main
main: {
.const buf = $1100
.label buf = $1100
//SEG10 [5] phi from main to main::@1 [phi:main->main::@1]
//SEG11 [5] phi (byte) main::i#2 = (byte/signed byte/word/signed word/dword/signed dword) 5 [phi:main->main::@1#0] -- vbuxx=vbuc1
ldx #5

2
src/test/java/dk/camelot64/kickc/test/ref/literals.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.label SCREEN = $400
.const char = 'a'
.const num = 1
jsr main

6
src/test/java/dk/camelot64/kickc/test/ref/literals.log
View File

@ -322,7 +322,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
.const char = 'a'
.const num = 1
//SEG2 @begin
@ -408,7 +408,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
.const char = 'a'
.const num = 1
//SEG2 @begin
@ -516,7 +516,7 @@ Score: 299
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
.const char = 'a'
.const num = 1
//SEG2 @begin

2
src/test/java/dk/camelot64/kickc/test/ref/liverange.asm
View File

@ -3,7 +3,7 @@
.pc = $80d "Program"
jsr main
main: {
.const SCREEN = $400
.label SCREEN = $400
.label a = 2
ldy #0
jsr inci

6
src/test/java/dk/camelot64/kickc/test/ref/liverange.log
View File

@ -442,7 +442,7 @@ bend_from_b2:
bend:
//SEG9 main
main: {
.const SCREEN = $400
.label SCREEN = $400
.label _0 = 4
.label _2 = 7
.label a = 5
@ -572,7 +572,7 @@ bend_from_b2:
bend:
//SEG9 main
main: {
.const SCREEN = $400
.label SCREEN = $400
.label a = 2
//SEG10 [5] call inci param-assignment [ inci::return#2 i#11 ] ( main:2 [ inci::return#2 i#11 ] )
//SEG11 [16] phi from main to inci [phi:main->inci]
@ -709,7 +709,7 @@ Score: 64
//SEG8 @end
//SEG9 main
main: {
.const SCREEN = $400
.label SCREEN = $400
.label a = 2
//SEG10 [5] call inci param-assignment [ inci::return#2 i#11 ] ( main:2 [ inci::return#2 i#11 ] )
//SEG11 [16] phi from main to inci [phi:main->inci]

2
src/test/java/dk/camelot64/kickc/test/ref/local-string.asm
View File

@ -3,7 +3,7 @@
.pc = $80d "Program"
jsr main
main: {
.const screen = $400
.label screen = $400
ldx #0
b1:
lda msg,x

6
src/test/java/dk/camelot64/kickc/test/ref/local-string.log
View File

@ -265,7 +265,7 @@ bend_from_b1:
bend:
//SEG9 main
main: {
.const screen = $400
.label screen = $400
.label i = 2
//SEG10 [5] phi from main to main::@1 [phi:main->main::@1]
b1_from_main:
@ -339,7 +339,7 @@ bend_from_b1:
bend:
//SEG9 main
main: {
.const screen = $400
.label screen = $400
//SEG10 [5] phi from main to main::@1 [phi:main->main::@1]
b1_from_main:
//SEG11 [5] phi (byte) main::i#2 = (byte/signed byte/word/signed word/dword/signed dword) 0 [phi:main->main::@1#0] -- vbuxx=vbuc1
@ -425,7 +425,7 @@ Score: 267
//SEG8 @end
//SEG9 main
main: {
.const screen = $400
.label screen = $400
//SEG10 [5] phi from main to main::@1 [phi:main->main::@1]
//SEG11 [5] phi (byte) main::i#2 = (byte/signed byte/word/signed word/dword/signed dword) 0 [phi:main->main::@1#0] -- vbuxx=vbuc1
ldx #0

2
src/test/java/dk/camelot64/kickc/test/ref/loopnest.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.label SCREEN = $400
jsr main
main: {
ldy #$64

6
src/test/java/dk/camelot64/kickc/test/ref/loopnest.log
View File

@ -345,7 +345,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @2 [phi:@begin->@2]
@ -444,7 +444,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @2 [phi:@begin->@2]
@ -582,7 +582,7 @@ Score: 1359
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @2 [phi:@begin->@2]
//SEG4 @2

2
src/test/java/dk/camelot64/kickc/test/ref/loopnest2.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.label SCREEN = $400
jsr main
main: {
.label j = 3

6
src/test/java/dk/camelot64/kickc/test/ref/loopnest2.log
View File

@ -720,7 +720,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @3 [phi:@begin->@3]
@ -927,7 +927,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @3 [phi:@begin->@3]
@ -1217,7 +1217,7 @@ Score: 13472241
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @3 [phi:@begin->@3]
//SEG4 @3

2
src/test/java/dk/camelot64/kickc/test/ref/loopnest3.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.label SCREEN = $400
jsr main
main: {
ldy #0

6
src/test/java/dk/camelot64/kickc/test/ref/loopnest3.log
View File

@ -408,7 +408,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @3 [phi:@begin->@3]
@ -532,7 +532,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @3 [phi:@begin->@3]
@ -694,7 +694,7 @@ Score: 1527
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @3 [phi:@begin->@3]
//SEG4 @3

2
src/test/java/dk/camelot64/kickc/test/ref/modglobal.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.label SCREEN = $400
.label cnt3 = 2
jsr main
main: {

6
src/test/java/dk/camelot64/kickc/test/ref/modglobal.log
View File

@ -534,7 +534,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
.label cnt = 2
.label cnt2 = 3
.label cnt3 = 4
@ -665,7 +665,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
.label cnt3 = 2
//SEG2 @begin
bbegin:
@ -819,7 +819,7 @@ Score: 60
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
.label cnt3 = 2
//SEG2 @begin
//SEG3 [1] phi from @begin to @2 [phi:@begin->@2]

2
src/test/java/dk/camelot64/kickc/test/ref/modglobalmin.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.label SCREEN = $400
jsr main
main: {
ldx #0

6
src/test/java/dk/camelot64/kickc/test/ref/modglobalmin.log
View File

@ -312,7 +312,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
.label cnt = 2
.label cnt_11 = 3
.label cnt_13 = 4
@ -405,7 +405,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @2 [phi:@begin->@2]
@ -520,7 +520,7 @@ Score: 46
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @2 [phi:@begin->@2]
//SEG4 @2

2
src/test/java/dk/camelot64/kickc/test/ref/overlap-allocation-2.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.label SCREEN = $400
jsr main
main: {
ldx #0

6
src/test/java/dk/camelot64/kickc/test/ref/overlap-allocation-2.log
View File

@ -504,7 +504,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @3 [phi:@begin->@3]
@ -663,7 +663,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @3 [phi:@begin->@3]
@ -866,7 +866,7 @@ Score: 235
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @3 [phi:@begin->@3]
//SEG4 @3

2
src/test/java/dk/camelot64/kickc/test/ref/overlap-allocation.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.label SCREEN = $400
jsr main
main: {
ldx #0

6
src/test/java/dk/camelot64/kickc/test/ref/overlap-allocation.log
View File

@ -492,7 +492,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @2 [phi:@begin->@2]
@ -647,7 +647,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @2 [phi:@begin->@2]
@ -849,7 +849,7 @@ Score: 298
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @2 [phi:@begin->@2]
//SEG4 @2

2
src/test/java/dk/camelot64/kickc/test/ref/print-problem.asm
View File

@ -1,7 +1,7 @@
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const SCREEN = $400
.label SCREEN = $400
jsr main
main: {
lda #$40

6
src/test/java/dk/camelot64/kickc/test/ref/print-problem.log
View File

@ -408,7 +408,7 @@ INITIAL ASM
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
.label line = 2
//SEG2 @begin
bbegin:
@ -500,7 +500,7 @@ ASSEMBLER BEFORE OPTIMIZATION
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
bbegin:
//SEG3 [1] phi from @begin to @2 [phi:@begin->@2]
@ -625,7 +625,7 @@ Score: 46
:BasicUpstart(main)
.pc = $80d "Program"
//SEG1 Global Constants & labels
.const SCREEN = $400
.label SCREEN = $400
//SEG2 @begin
//SEG3 [1] phi from @begin to @2 [phi:@begin->@2]
//SEG4 @2

6
src/test/java/dk/camelot64/kickc/test/ref/ptr-complex.asm
View File

@ -3,9 +3,9 @@
.pc = $80d "Program"
jsr main
main: {
.const screen = $400
.const BGCOL = $d020
.const sc2 = screen+$51
.label screen = $400
.label BGCOL = $d020
.label sc2 = screen+$51
.label _2 = 2
.label _9 = 2
.label _11 = 4

18
src/test/java/dk/camelot64/kickc/test/ref/ptr-complex.log
View File

@ -510,9 +510,9 @@ bend_from_b1:
bend:
//SEG9 main
main: {
.const screen = $400
.const BGCOL = $d020
.const sc2 = screen+$51
.label screen = $400
.label BGCOL = $d020
.label sc2 = screen+$51
.label _2 = 4
.label _9 = 6
.label _11 = 8
@ -672,9 +672,9 @@ bend_from_b1:
bend:
//SEG9 main
main: {
.const screen = $400
.const BGCOL = $d020
.const sc2 = screen+$51
.label screen = $400
.label BGCOL = $d020
.label sc2 = screen+$51
.label _2 = 2
.label _9 = 2
.label _11 = 4
@ -850,9 +850,9 @@ Score: 956
//SEG8 @end
//SEG9 main
main: {
.const screen = $400
.const BGCOL = $d020
.const sc2 = screen+$51
.label screen = $400
.label BGCOL = $d020
.label sc2 = screen+$51
.label _2 = 2
.label _9 = 2
.label _11 = 4

2
src/test/java/dk/camelot64/kickc/test/ref/ptrtest.asm
View File

@ -62,7 +62,7 @@ rvalue: {
jmp b1
}
lvalue: {
.const SCREEN = $400
.label SCREEN = $400
lda #1
sta SCREEN
lda #2

Some files were not shown because too many files have changed in this diff Show More