mirror of
https://github.com/irmen/prog8.git
synced 2024-11-26 11:49:22 +00:00
531 lines
22 KiB
Kotlin
531 lines
22 KiB
Kotlin
package prog8tests
|
|
|
|
import io.kotest.assertions.fail
|
|
import io.kotest.assertions.withClue
|
|
import io.kotest.core.spec.style.FunSpec
|
|
import io.kotest.matchers.shouldBe
|
|
import io.kotest.matchers.shouldNotBe
|
|
import io.kotest.matchers.string.shouldContain
|
|
import io.kotest.matchers.types.instanceOf
|
|
import io.kotest.matchers.types.shouldBeSameInstanceAs
|
|
import prog8.ast.Program
|
|
import prog8.ast.base.DataType
|
|
import prog8.ast.base.ParentSentinel
|
|
import prog8.ast.base.Position
|
|
import prog8.ast.expressions.*
|
|
import prog8.ast.statements.*
|
|
import prog8.compiler.BeforeAsmGenerationAstChanger
|
|
import prog8.compiler.target.C64Target
|
|
import prog8.compilerinterface.*
|
|
import prog8tests.helpers.*
|
|
import prog8tests.helpers.DummyFunctions
|
|
import prog8tests.helpers.DummyMemsizer
|
|
import prog8tests.helpers.DummyStringEncoder
|
|
import prog8tests.helpers.ErrorReporterForTests
|
|
import prog8tests.helpers.assertSuccess
|
|
import prog8tests.helpers.compileText
|
|
import prog8tests.helpers.generateAssembly
|
|
|
|
class TestOptimization: FunSpec({
|
|
test("remove empty subroutine except start") {
|
|
val sourcecode = """
|
|
main {
|
|
sub start() {
|
|
}
|
|
sub empty() {
|
|
; going to be removed
|
|
}
|
|
}
|
|
"""
|
|
val result = compileText(C64Target, true, sourcecode).assertSuccess()
|
|
val toplevelModule = result.program.toplevelModule
|
|
val mainBlock = toplevelModule.statements.single() as Block
|
|
val startSub = mainBlock.statements.single() as Subroutine
|
|
result.program.entrypoint shouldBeSameInstanceAs startSub
|
|
withClue("only start sub should remain") {
|
|
startSub.name shouldBe "start"
|
|
}
|
|
withClue("compiler has inserted return in empty subroutines") {
|
|
startSub.statements.single() shouldBe instanceOf<Return>()
|
|
}
|
|
}
|
|
|
|
test("don't remove empty subroutine if it's referenced") {
|
|
val sourcecode = """
|
|
main {
|
|
sub start() {
|
|
uword xx = &empty
|
|
xx++
|
|
}
|
|
sub empty() {
|
|
; should not be removed
|
|
}
|
|
}
|
|
"""
|
|
val result = compileText(C64Target, true, sourcecode).assertSuccess()
|
|
val toplevelModule = result.program.toplevelModule
|
|
val mainBlock = toplevelModule.statements.single() as Block
|
|
val startSub = mainBlock.statements[0] as Subroutine
|
|
val emptySub = mainBlock.statements[1] as Subroutine
|
|
result.program.entrypoint shouldBeSameInstanceAs startSub
|
|
startSub.name shouldBe "start"
|
|
emptySub.name shouldBe "empty"
|
|
withClue("compiler has inserted return in empty subroutines") {
|
|
emptySub.statements.single() shouldBe instanceOf<Return>()
|
|
}
|
|
}
|
|
|
|
test("generated constvalue from typecast inherits proper parent linkage") {
|
|
val number = NumericLiteralValue(DataType.UBYTE, 11.0, Position.DUMMY)
|
|
val tc = TypecastExpression(number, DataType.BYTE, false, Position.DUMMY)
|
|
val program = Program("test", DummyFunctions, DummyMemsizer, DummyStringEncoder)
|
|
tc.linkParents(ParentSentinel)
|
|
tc.parent shouldNotBe null
|
|
number.parent shouldNotBe null
|
|
tc shouldBeSameInstanceAs number.parent
|
|
val constvalue = tc.constValue(program)!!
|
|
constvalue shouldBe instanceOf<NumericLiteralValue>()
|
|
constvalue.number shouldBe 11.0
|
|
constvalue.type shouldBe DataType.BYTE
|
|
constvalue.parent shouldBeSameInstanceAs tc.parent
|
|
}
|
|
|
|
test("generated constvalue from prefixexpr inherits proper parent linkage") {
|
|
val number = NumericLiteralValue(DataType.UBYTE, 11.0, Position.DUMMY)
|
|
val pfx = PrefixExpression("-", number, Position.DUMMY)
|
|
val program = Program("test", DummyFunctions, DummyMemsizer, DummyStringEncoder)
|
|
pfx.linkParents(ParentSentinel)
|
|
pfx.parent shouldNotBe null
|
|
number.parent shouldNotBe null
|
|
pfx shouldBeSameInstanceAs number.parent
|
|
val constvalue = pfx.constValue(program)!!
|
|
constvalue shouldBe instanceOf<NumericLiteralValue>()
|
|
constvalue.number shouldBe -11.0
|
|
constvalue.type shouldBe DataType.BYTE
|
|
constvalue.parent shouldBeSameInstanceAs pfx.parent
|
|
}
|
|
|
|
test("constantfolded and silently typecasted for initializervalues") {
|
|
val sourcecode = """
|
|
main {
|
|
sub start() {
|
|
const ubyte TEST = 10
|
|
byte @shared x1 = TEST as byte + 1
|
|
byte @shared x2 = 1 + TEST as byte
|
|
ubyte @shared y1 = TEST + 1 as byte
|
|
ubyte @shared y2 = 1 as byte + TEST
|
|
}
|
|
}
|
|
"""
|
|
val result = compileText(C64Target, true, sourcecode).assertSuccess()
|
|
val mainsub = result.program.entrypoint
|
|
mainsub.statements.size shouldBe 10
|
|
val declTest = mainsub.statements[0] as VarDecl
|
|
val declX1 = mainsub.statements[1] as VarDecl
|
|
val initX1 = mainsub.statements[2] as Assignment
|
|
val declX2 = mainsub.statements[3] as VarDecl
|
|
val initX2 = mainsub.statements[4] as Assignment
|
|
val declY1 = mainsub.statements[5] as VarDecl
|
|
val initY1 = mainsub.statements[6] as Assignment
|
|
val declY2 = mainsub.statements[7] as VarDecl
|
|
val initY2 = mainsub.statements[8] as Assignment
|
|
mainsub.statements[9] shouldBe instanceOf<Return>()
|
|
(declTest.value as NumericLiteralValue).number shouldBe 10.0
|
|
declX1.value shouldBe null
|
|
declX2.value shouldBe null
|
|
declY1.value shouldBe null
|
|
declY2.value shouldBe null
|
|
(initX1.value as NumericLiteralValue).type shouldBe DataType.BYTE
|
|
(initX1.value as NumericLiteralValue).number shouldBe 11.0
|
|
(initX2.value as NumericLiteralValue).type shouldBe DataType.BYTE
|
|
(initX2.value as NumericLiteralValue).number shouldBe 11.0
|
|
(initY1.value as NumericLiteralValue).type shouldBe DataType.UBYTE
|
|
(initY1.value as NumericLiteralValue).number shouldBe 11.0
|
|
(initY2.value as NumericLiteralValue).type shouldBe DataType.UBYTE
|
|
(initY2.value as NumericLiteralValue).number shouldBe 11.0
|
|
}
|
|
|
|
test("typecasted assignment from ubyte logical expressoin to uword var") {
|
|
val src = """
|
|
main {
|
|
sub start() {
|
|
ubyte bb
|
|
uword ww
|
|
ww = not bb or not ww ; expression combining ubyte and uword
|
|
}
|
|
}
|
|
"""
|
|
val result = compileText(C64Target, false, src, writeAssembly = false).assertSuccess()
|
|
|
|
// ww = ((( not bb as uword) or not ww) as uword)
|
|
val wwAssign = result.program.entrypoint.statements.last() as Assignment
|
|
val expr = wwAssign.value as TypecastExpression
|
|
|
|
wwAssign.target.identifier?.nameInSource shouldBe listOf("ww")
|
|
expr.type shouldBe DataType.UWORD
|
|
expr.expression.inferType(result.program).istype(DataType.UBYTE) shouldBe true
|
|
}
|
|
|
|
test("intermediate assignment steps have correct types for codegen phase (BeforeAsmGenerationAstChanger)") {
|
|
val src = """
|
|
main {
|
|
sub start() {
|
|
ubyte bb
|
|
uword ww
|
|
bb = not bb or not ww ; expression combining ubyte and uword
|
|
}
|
|
}
|
|
"""
|
|
val result = compileText(C64Target, false, src, writeAssembly = false).assertSuccess()
|
|
|
|
// bb = (( not bb as uword) or not ww)
|
|
val bbAssign = result.program.entrypoint.statements.last() as Assignment
|
|
val expr = bbAssign.value as BinaryExpression
|
|
expr.operator shouldBe "or"
|
|
expr.left shouldBe instanceOf<TypecastExpression>() // casted to word
|
|
expr.right shouldBe instanceOf<PrefixExpression>()
|
|
expr.left.inferType(result.program).getOrElse { fail("dt") } shouldBe DataType.UWORD
|
|
expr.right.inferType(result.program).getOrElse { fail("dt") } shouldBe DataType.UWORD
|
|
expr.inferType(result.program).getOrElse { fail("dt") } shouldBe DataType.UBYTE
|
|
|
|
val options = CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.DONTUSE, emptyList(), false, true, C64Target)
|
|
val changer = BeforeAsmGenerationAstChanger(result.program,
|
|
options,
|
|
ErrorReporterForTests()
|
|
)
|
|
|
|
changer.visit(result.program)
|
|
while(changer.applyModifications()>0) {
|
|
changer.visit(result.program)
|
|
}
|
|
|
|
// assignment is now split into:
|
|
// bb = not bb
|
|
// bb = (bb or not ww)
|
|
|
|
val assigns = result.program.entrypoint.statements.filterIsInstance<Assignment>()
|
|
val bbAssigns = assigns.filter { it.value !is NumericLiteralValue }
|
|
bbAssigns.size shouldBe 2
|
|
|
|
bbAssigns[0].target.identifier!!.nameInSource shouldBe listOf("bb")
|
|
bbAssigns[0].value shouldBe instanceOf<PrefixExpression>()
|
|
(bbAssigns[0].value as PrefixExpression).operator shouldBe "not"
|
|
(bbAssigns[0].value as PrefixExpression).expression shouldBe IdentifierReference(listOf("bb"), Position.DUMMY)
|
|
bbAssigns[0].value.inferType(result.program).getOrElse { fail("dt") } shouldBe DataType.UBYTE
|
|
|
|
bbAssigns[1].target.identifier!!.nameInSource shouldBe listOf("bb")
|
|
val bbAssigns1expr = bbAssigns[1].value as BinaryExpression
|
|
bbAssigns1expr.operator shouldBe "or"
|
|
bbAssigns1expr.left shouldBe IdentifierReference(listOf("bb"), Position.DUMMY)
|
|
bbAssigns1expr.right shouldBe instanceOf<PrefixExpression>()
|
|
(bbAssigns1expr.right as PrefixExpression).operator shouldBe "not"
|
|
(bbAssigns1expr.right as PrefixExpression).expression shouldBe IdentifierReference(listOf("ww"), Position.DUMMY)
|
|
bbAssigns1expr.inferType(result.program).getOrElse { fail("dt") } shouldBe DataType.UBYTE
|
|
|
|
val asm = generateAssembly(result.program, options)
|
|
asm.valid shouldBe true
|
|
}
|
|
|
|
test("intermediate assignment steps generated for typecasted expression") {
|
|
val src = """
|
|
main {
|
|
sub start() {
|
|
ubyte r
|
|
ubyte @shared bb = (cos8(r)/2 + 100) as ubyte
|
|
}
|
|
}
|
|
"""
|
|
val result = compileText(C64Target, true, src, writeAssembly = true).assertSuccess()
|
|
/* turned into:
|
|
ubyte r
|
|
r = 0
|
|
ubyte bb
|
|
prog8_lib.retval_interm_b = cos8(r)
|
|
prog8_lib.retval_interm_b >>= 1
|
|
prog8_lib.retval_interm_b += 100
|
|
bb = prog8_lib.retval_interm_b
|
|
return
|
|
*/
|
|
val st = result.program.entrypoint.statements
|
|
st.size shouldBe 8
|
|
st.last() shouldBe instanceOf<Return>()
|
|
var assign = st[3] as Assignment
|
|
assign.target.identifier!!.nameInSource shouldBe listOf("prog8_lib","retval_interm_b")
|
|
assign = st[4] as Assignment
|
|
assign.target.identifier!!.nameInSource shouldBe listOf("prog8_lib","retval_interm_b")
|
|
assign = st[5] as Assignment
|
|
assign.target.identifier!!.nameInSource shouldBe listOf("prog8_lib","retval_interm_b")
|
|
assign = st[6] as Assignment
|
|
assign.target.identifier!!.nameInSource shouldBe listOf("bb")
|
|
}
|
|
|
|
test("asmgen correctly deals with float typecasting in augmented assignment") {
|
|
val src="""
|
|
%option enable_floats
|
|
|
|
main {
|
|
sub start() {
|
|
ubyte ub
|
|
float ff = 1.0
|
|
ff += (ub as float) ; operator doesn't matter
|
|
}
|
|
}
|
|
"""
|
|
val result = compileText(C64Target, optimize=false, src, writeAssembly = false).assertSuccess()
|
|
val assignFF = result.program.entrypoint.statements.last() as Assignment
|
|
assignFF.isAugmentable shouldBe true
|
|
assignFF.target.identifier!!.nameInSource shouldBe listOf("ff")
|
|
val value = assignFF.value as BinaryExpression
|
|
value.operator shouldBe "+"
|
|
value.left shouldBe IdentifierReference(listOf("ff"), Position.DUMMY)
|
|
value.right shouldBe instanceOf<TypecastExpression>()
|
|
|
|
val asm = generateAssembly(result.program)
|
|
asm.valid shouldBe true
|
|
}
|
|
|
|
test("unused variable removal") {
|
|
val src="""
|
|
main {
|
|
sub start() {
|
|
ubyte unused
|
|
ubyte @shared unused_but_shared ; this one should remain
|
|
ubyte usedvar_only_written
|
|
usedvar_only_written=2
|
|
usedvar_only_written++
|
|
ubyte usedvar ; and this one too
|
|
usedvar = msb(usedvar)
|
|
}
|
|
}
|
|
"""
|
|
val result = compileText(C64Target, optimize=true, src, writeAssembly=false).assertSuccess()
|
|
result.program.entrypoint.statements.size shouldBe 4 // unused_but_shared decl, unused_but_shared=0, usedvar decl, usedvar assign
|
|
val (decl, assign, decl2, assign2) = result.program.entrypoint.statements
|
|
decl shouldBe instanceOf<VarDecl>()
|
|
(decl as VarDecl).name shouldBe "unused_but_shared"
|
|
assign shouldBe instanceOf<Assignment>()
|
|
decl2 shouldBe instanceOf<VarDecl>()
|
|
(decl2 as VarDecl).name shouldBe "usedvar"
|
|
assign2 shouldBe instanceOf<Assignment>()
|
|
}
|
|
|
|
test("unused variable removal from subscope") {
|
|
val src="""
|
|
main {
|
|
sub start() {
|
|
if cx16.r0 {
|
|
uword xx = 42 ; to be removed
|
|
xx=99 ; to be removed
|
|
cx16.r0 = 0
|
|
}
|
|
func2()
|
|
|
|
sub func2() {
|
|
uword yy = 33 ; to be removed
|
|
yy=99 ; to be removed
|
|
cx16.r0 = 0
|
|
}
|
|
}
|
|
}"""
|
|
val result = compileText(C64Target, optimize=true, src, writeAssembly=false).assertSuccess()
|
|
result.program.entrypoint.statements.size shouldBe 3
|
|
val ifstmt = result.program.entrypoint.statements[0] as IfStatement
|
|
ifstmt.truepart.statements.size shouldBe 1
|
|
(ifstmt.truepart.statements[0] as Assignment).target.identifier!!.nameInSource shouldBe listOf("cx16", "r0")
|
|
val func2 = result.program.entrypoint.statements[2] as Subroutine
|
|
func2.statements.size shouldBe 1
|
|
(func2.statements[0] as Assignment).target.identifier!!.nameInSource shouldBe listOf("cx16", "r0")
|
|
}
|
|
|
|
test("test simple augmented assignment optimization correctly initializes all variables") {
|
|
val src="""
|
|
main {
|
|
sub start() {
|
|
ubyte @shared z1
|
|
z1 = 10
|
|
ubyte @shared z2
|
|
z2 = ~z2
|
|
ubyte @shared z3
|
|
z3 = not z3
|
|
uword @shared z4
|
|
z4 = (z4 as ubyte)
|
|
ubyte @shared z5
|
|
z5 = z1+z5+5
|
|
ubyte @shared z6
|
|
z6 = z1+z6-5
|
|
}
|
|
}"""
|
|
val result = compileText(C64Target, optimize=true, src, writeAssembly=false).assertSuccess()
|
|
/* expected:
|
|
ubyte z1
|
|
z1 = 10
|
|
ubyte z2
|
|
z2 = 255
|
|
ubyte z3
|
|
z3 = 1
|
|
uword z4
|
|
z4 = 0
|
|
ubyte z5
|
|
z5 = z1
|
|
z5 += 5
|
|
ubyte z6
|
|
z6 = z1
|
|
z6 -= 5
|
|
*/
|
|
val statements = result.program.entrypoint.statements
|
|
statements.size shouldBe 14
|
|
val z1decl = statements[0] as VarDecl
|
|
val z1init = statements[1] as Assignment
|
|
val z2decl = statements[2] as VarDecl
|
|
val z2init = statements[3] as Assignment
|
|
val z3decl = statements[4] as VarDecl
|
|
val z3init = statements[5] as Assignment
|
|
val z4decl = statements[6] as VarDecl
|
|
val z4init = statements[7] as Assignment
|
|
val z5decl = statements[8] as VarDecl
|
|
val z5init = statements[9] as Assignment
|
|
val z5plus = statements[10] as Assignment
|
|
val z6decl = statements[11] as VarDecl
|
|
val z6init = statements[12] as Assignment
|
|
val z6plus = statements[13] as Assignment
|
|
|
|
z1decl.name shouldBe "z1"
|
|
z1init.value shouldBe NumericLiteralValue(DataType.UBYTE, 10.0, Position.DUMMY)
|
|
z2decl.name shouldBe "z2"
|
|
z2init.value shouldBe NumericLiteralValue(DataType.UBYTE, 255.0, Position.DUMMY)
|
|
z3decl.name shouldBe "z3"
|
|
z3init.value shouldBe NumericLiteralValue(DataType.UBYTE, 1.0, Position.DUMMY)
|
|
z4decl.name shouldBe "z4"
|
|
z4init.value shouldBe NumericLiteralValue(DataType.UBYTE, 0.0, Position.DUMMY)
|
|
z5decl.name shouldBe "z5"
|
|
z5init.value shouldBe IdentifierReference(listOf("z1"), Position.DUMMY)
|
|
z5plus.isAugmentable shouldBe true
|
|
(z5plus.value as BinaryExpression).operator shouldBe "+"
|
|
(z5plus.value as BinaryExpression).right shouldBe NumericLiteralValue(DataType.UBYTE, 5.0, Position.DUMMY)
|
|
z6decl.name shouldBe "z6"
|
|
z6init.value shouldBe IdentifierReference(listOf("z1"), Position.DUMMY)
|
|
z6plus.isAugmentable shouldBe true
|
|
(z6plus.value as BinaryExpression).operator shouldBe "-"
|
|
(z6plus.value as BinaryExpression).right shouldBe NumericLiteralValue(DataType.UBYTE, 5.0, Position.DUMMY)
|
|
}
|
|
|
|
test("force_output option should work with optimizing memwrite assignment") {
|
|
val src="""
|
|
main {
|
|
%option force_output
|
|
|
|
sub start() {
|
|
uword aa
|
|
ubyte zz
|
|
@(aa) = zz + 32
|
|
}
|
|
}
|
|
"""
|
|
|
|
val result = compileText(C64Target, optimize=true, src, writeAssembly=false).assertSuccess()
|
|
val stmts = result.program.entrypoint.statements
|
|
stmts.size shouldBe 6
|
|
val assign=stmts.last() as Assignment
|
|
(assign.target.memoryAddress?.addressExpression as IdentifierReference).nameInSource shouldBe listOf("aa")
|
|
}
|
|
|
|
test("don't optimize memory writes away") {
|
|
val src="""
|
|
main {
|
|
sub start() {
|
|
uword aa
|
|
ubyte zz
|
|
@(aa) = zz + 32 ; do not optimize this away!
|
|
}
|
|
}
|
|
"""
|
|
val result = compileText(C64Target, optimize=true, src, writeAssembly=false).assertSuccess()
|
|
val stmts = result.program.entrypoint.statements
|
|
stmts.size shouldBe 6
|
|
val assign=stmts.last() as Assignment
|
|
(assign.target.memoryAddress?.addressExpression as IdentifierReference).nameInSource shouldBe listOf("aa")
|
|
}
|
|
|
|
test("correctly process constant prefix numbers") {
|
|
val src="""
|
|
main {
|
|
sub start() {
|
|
ubyte @shared z1 = 1
|
|
ubyte @shared z2 = + 1
|
|
ubyte @shared z3 = ~ 1
|
|
ubyte @shared z4 = not 1
|
|
byte @shared z5 = - 1
|
|
}
|
|
}
|
|
"""
|
|
val result = compileText(C64Target, optimize=true, src, writeAssembly=false).assertSuccess()
|
|
val stmts = result.program.entrypoint.statements
|
|
stmts.size shouldBe 10
|
|
stmts.filterIsInstance<VarDecl>().size shouldBe 5
|
|
stmts.filterIsInstance<Assignment>().size shouldBe 5
|
|
}
|
|
|
|
test("correctly process constant prefix numbers with type mismatch and give error") {
|
|
val src="""
|
|
main {
|
|
sub start() {
|
|
ubyte @shared z1 = - 1
|
|
}
|
|
}
|
|
"""
|
|
val errors = ErrorReporterForTests()
|
|
compileText(C64Target, optimize=true, src, writeAssembly=false, errors = errors).assertFailure()
|
|
errors.errors.size shouldBe 2
|
|
errors.errors[0] shouldContain "type of value BYTE doesn't match target UBYTE"
|
|
errors.errors[1] shouldContain "value '-1' out of range for unsigned byte"
|
|
}
|
|
|
|
test("test augmented expression asmgen") {
|
|
val src = """
|
|
main {
|
|
sub start() {
|
|
ubyte c
|
|
ubyte r
|
|
ubyte q
|
|
r = (q+r)-c
|
|
q=r
|
|
r = q+(r-c)
|
|
q=r
|
|
}
|
|
}"""
|
|
val result = compileText(C64Target, optimize=false, src, writeAssembly=true).assertSuccess()
|
|
result.program.entrypoint.statements.size shouldBe 11
|
|
result.program.entrypoint.statements.last() shouldBe instanceOf<Return>()
|
|
}
|
|
|
|
test("keep the value initializer assignment if the next one depends on it") {
|
|
val src="""
|
|
main {
|
|
sub start() {
|
|
uword @shared yy
|
|
yy = 20 ; ok to remove =0 initializer before this
|
|
uword @shared zz
|
|
zz += 60 ; NOT ok to remove initializer, should evaluate to 60
|
|
ubyte @shared xx
|
|
xx = 6+sin8u(xx) ; NOT ok to remove initializer
|
|
}
|
|
}
|
|
"""
|
|
val result = compileText(C64Target, optimize=true, src, writeAssembly=false).assertSuccess()
|
|
/* expected result:
|
|
uword yy
|
|
yy = 20
|
|
uword zz
|
|
zz = 60
|
|
ubyte xx
|
|
xx = 0
|
|
xx = sin8u(xx)
|
|
xx += 6
|
|
*/
|
|
val stmts = result.program.entrypoint.statements
|
|
stmts.size shouldBe 8
|
|
stmts.filterIsInstance<VarDecl>().size shouldBe 3
|
|
stmts.filterIsInstance<Assignment>().size shouldBe 5
|
|
}
|
|
})
|