Apple-2-SW/prog8
1
0
Fork 0
mirror of https://github.com/irmen/prog8.git synced 2025-02-25 04:29:36 +00:00
Code Issues Projects Releases Wiki Activity

refactoring asmassignment code blocks into utility functions

Browse Source
This commit is contained in:
Irmen de Jong 2020-11-15 15:04:23 +01:00
parent 5c9e0c9f51
commit 5ebaaff64b
5 changed files with 41 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt
View File

@ -14,11 +14,8 @@ import prog8.compiler.target.IAssemblyGenerator
import prog8.compiler.target.IAssemblyProgram import prog8.compiler.target.IAssemblyProgram
import prog8.compiler.target.c64.AssemblyProgram import prog8.compiler.target.c64.AssemblyProgram
import prog8.compiler.target.c64.Petscii import prog8.compiler.target.c64.Petscii
import prog8.compiler.target.c64.codegen.assignment.AsmAssignSource
import prog8.compiler.target.c64.codegen.assignment.AsmAssignTarget
import prog8.compiler.target.c64.codegen.assignment.AsmAssignment import prog8.compiler.target.c64.codegen.assignment.AsmAssignment
import prog8.compiler.target.c64.codegen.assignment.AssignmentAsmGen import prog8.compiler.target.c64.codegen.assignment.AssignmentAsmGen
import prog8.compiler.target.c64.codegen.assignment.TargetStorageKind
import prog8.compiler.target.generatedLabelPrefix import prog8.compiler.target.generatedLabelPrefix
import prog8.functions.BuiltinFunctions import prog8.functions.BuiltinFunctions
import prog8.functions.FSignature import prog8.functions.FSignature
@ -201,11 +198,7 @@ internal class AsmGen(private val program: Program,
private fun assignInitialValueToVar(decl: VarDecl, variableName: List<String>) { private fun assignInitialValueToVar(decl: VarDecl, variableName: List<String>) {
val asmName = asmVariableName(variableName) val asmName = asmVariableName(variableName)
val asgn = AsmAssignment( assignmentAsmGen.assignExpressionToVariable(decl.value!!, asmName, decl.datatype, decl.definingSubroutine())
AsmAssignSource.fromAstSource(decl.value!!, program, this),
AsmAssignTarget(TargetStorageKind.VARIABLE, program, this, decl.datatype, decl.definingSubroutine(), variableAsmName = asmName),
false, decl.position)
assignmentAsmGen.translateNormalAssignment(asgn)
} }
private var generatedLabelSequenceNumber: Int = 0 private var generatedLabelSequenceNumber: Int = 0
@ -752,6 +745,12 @@ internal class AsmGen(private val program: Program,
internal fun translateNormalAssignment(assign: AsmAssignment) = internal fun translateNormalAssignment(assign: AsmAssignment) =
assignmentAsmGen.translateNormalAssignment(assign) assignmentAsmGen.translateNormalAssignment(assign)
internal fun assignExpressionToRegister(expr: Expression, register: RegisterOrPair) =
assignmentAsmGen.assignExpressionToRegister(expr, register)
internal fun assignExpressionToVariable(expr: Expression, asmVarName: String, dt: DataType, scope: Subroutine?) =
assignmentAsmGen.assignExpressionToVariable(expr, asmVarName, dt, scope)
private fun translateSubroutine(sub: Subroutine) { private fun translateSubroutine(sub: Subroutine) {
out("") out("")
outputSourceLine(sub) outputSourceLine(sub)
@ -1163,16 +1162,12 @@ $label nop""")
val sub = ret.definingSubroutine()!! val sub = ret.definingSubroutine()!!
val returnType = sub.returntypes.single() val returnType = sub.returntypes.single()
val returnReg = sub.asmReturnvaluesRegisters.single() val returnReg = sub.asmReturnvaluesRegisters.single()
val returnValueTarget = if(returnReg.registerOrPair==null)
when { throw AssemblyError("normal subroutines can't return value in status register directly")
returnReg.registerOrPair!=null -> AsmAssignTarget.fromRegisters(returnReg.registerOrPair, sub, program, this)
else -> throw AssemblyError("normal subroutines can't return value in status register directly")
}
when (returnType) { when (returnType) {
in IntegerDatatypes -> { in IntegerDatatypes -> {
val src = AsmAssignSource.fromAstSource(returnvalue, program, this) assignmentAsmGen.assignExpressionToRegister(returnvalue, returnReg.registerOrPair)
assignmentAsmGen.translateNormalAssignment(AsmAssignment(src, returnValueTarget, false, ret.position))
} }
DataType.FLOAT -> { DataType.FLOAT -> {
// return the float value via FAC1 // return the float value via FAC1
@ -1192,8 +1187,7 @@ $label nop""")
else -> { else -> {
// all else take its address and assign that also to AY register pair // all else take its address and assign that also to AY register pair
val addrofValue = AddressOf(returnvalue as IdentifierReference, returnvalue.position) val addrofValue = AddressOf(returnvalue as IdentifierReference, returnvalue.position)
val src = AsmAssignSource.fromAstSource(addrofValue, program, this) assignmentAsmGen.assignExpressionToRegister(addrofValue, returnReg.registerOrPair)
assignmentAsmGen.translateNormalAssignment(AsmAssignment(src, returnValueTarget, false, ret.position))
} }
} }
} }

40
compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt
View File

@ -101,18 +101,9 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
when(func.name) { when(func.name) {
"memset" -> { "memset" -> {
// use the ROM function of the Cx16 // use the ROM function of the Cx16
var src = AsmAssignSource.fromAstSource(fcall.args[0], program, asmgen) asmgen.assignExpressionToVariable(fcall.args[0], "cx16.r0", DataType.UWORD, scope)
var tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, null, variableAsmName = "cx16.r0") asmgen.assignExpressionToVariable(fcall.args[1], "cx16.r1", DataType.UWORD, scope)
var assign = AsmAssignment(src, tgt, false, Position.DUMMY) asmgen.assignExpressionToRegister(fcall.args[2], RegisterOrPair.A)
asmgen.translateNormalAssignment(assign)
src = AsmAssignSource.fromAstSource(fcall.args[1], program, asmgen)
tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, null, variableAsmName = "cx16.r1")
assign = AsmAssignment(src, tgt, false, Position.DUMMY)
asmgen.translateNormalAssignment(assign)
src = AsmAssignSource.fromAstSource(fcall.args[2], program, asmgen)
tgt = AsmAssignTarget(TargetStorageKind.REGISTER, program, asmgen, DataType.UBYTE, null, register = RegisterOrPair.A)
assign = AsmAssignment(src, tgt, false, Position.DUMMY)
asmgen.translateNormalAssignment(assign)
val sub = (fcall as FunctionCallStatement).definingSubroutine()!! val sub = (fcall as FunctionCallStatement).definingSubroutine()!!
asmgen.saveRegister(CpuRegister.X, false, sub) asmgen.saveRegister(CpuRegister.X, false, sub)
asmgen.out(" jsr cx16.memory_fill") asmgen.out(" jsr cx16.memory_fill")
@ -129,18 +120,9 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
} }
// use the ROM function of the Cx16 // use the ROM function of the Cx16
var src = AsmAssignSource.fromAstSource(fcall.args[0], program, asmgen) asmgen.assignExpressionToVariable(fcall.args[0], "cx16.r0", DataType.UWORD, scope)
var tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, null, variableAsmName = "cx16.r0") asmgen.assignExpressionToVariable(fcall.args[1], "cx16.r1", DataType.UWORD, scope)
var assign = AsmAssignment(src, tgt, false, Position.DUMMY) asmgen.assignExpressionToVariable(fcall.args[2], "cx16.r2", DataType.UWORD, scope)
asmgen.translateNormalAssignment(assign)
src = AsmAssignSource.fromAstSource(fcall.args[1], program, asmgen)
tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, null, variableAsmName = "cx16.r1")
assign = AsmAssignment(src, tgt, false, Position.DUMMY)
asmgen.translateNormalAssignment(assign)
src = AsmAssignSource.fromAstSource(fcall.args[2], program, asmgen)
tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, null, variableAsmName = "cx16.r2")
assign = AsmAssignment(src, tgt, false, Position.DUMMY)
asmgen.translateNormalAssignment(assign)
val sub = (fcall as FunctionCallStatement).definingSubroutine()!! val sub = (fcall as FunctionCallStatement).definingSubroutine()!!
asmgen.saveRegister(CpuRegister.X, false, sub) asmgen.saveRegister(CpuRegister.X, false, sub)
asmgen.out(" jsr cx16.memory_copy") asmgen.out(" jsr cx16.memory_copy")
@ -995,10 +977,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
if (resultToStack) if (resultToStack)
asmgen.out(" sta P8ESTACK_LO,x | dex") asmgen.out(" sta P8ESTACK_LO,x | dex")
} else { } else {
val src = AsmAssignSource.fromAstSource(fcall.args.single(), program, asmgen) asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
val tgt = AsmAssignTarget.fromRegisters(RegisterOrPair.AY, null, program, asmgen)
val assign = AsmAssignment(src, tgt, false, (fcall as Node).position)
asmgen.translateNormalAssignment(assign)
if (resultToStack) if (resultToStack)
asmgen.out(" tya | sta P8ESTACK_LO,x | dex") asmgen.out(" tya | sta P8ESTACK_LO,x | dex")
else else
@ -1019,10 +998,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
if (resultToStack) if (resultToStack)
asmgen.out(" sta P8ESTACK_LO,x | dex") asmgen.out(" sta P8ESTACK_LO,x | dex")
} else { } else {
val src = AsmAssignSource.fromAstSource(fcall.args.single(), program, asmgen) asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
val tgt = AsmAssignTarget.fromRegisters(RegisterOrPair.AY, null, program, asmgen)
val assign = AsmAssignment(src, tgt, false, (fcall as Node).position)
asmgen.translateNormalAssignment(assign)
if (resultToStack) if (resultToStack)
asmgen.out(" sta P8ESTACK_LO,x | dex") asmgen.out(" sta P8ESTACK_LO,x | dex")
} }

14
compiler/src/prog8/compiler/target/c64/codegen/ExpressionsAsmGen.kt
View File

@ -9,10 +9,6 @@ import prog8.ast.statements.Subroutine
import prog8.compiler.AssemblyError import prog8.compiler.AssemblyError
import prog8.compiler.target.CompilationTarget import prog8.compiler.target.CompilationTarget
import prog8.compiler.target.CpuType import prog8.compiler.target.CpuType
import prog8.compiler.target.c64.codegen.assignment.AsmAssignSource
import prog8.compiler.target.c64.codegen.assignment.AsmAssignTarget
import prog8.compiler.target.c64.codegen.assignment.AsmAssignment
import prog8.compiler.target.c64.codegen.assignment.TargetStorageKind
import prog8.compiler.toHex import prog8.compiler.toHex
import prog8.functions.BuiltinFunctions import prog8.functions.BuiltinFunctions
import kotlin.math.absoluteValue import kotlin.math.absoluteValue
@ -1730,14 +1726,8 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
} }
private fun translateCompareStrings(s1: Expression, operator: String, s2: Expression) { private fun translateCompareStrings(s1: Expression, operator: String, s2: Expression) {
var src = AsmAssignSource.fromAstSource(s1, program, asmgen) asmgen.assignExpressionToVariable(s1, "prog8_lib.strcmp_expression._arg_s1", DataType.UWORD, null)
var tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, null, variableAsmName = "prog8_lib.strcmp_expression._arg_s1") asmgen.assignExpressionToVariable(s2, "prog8_lib.strcmp_expression._arg_s2", DataType.UWORD, null)
var assign = AsmAssignment(src, tgt, false, Position.DUMMY)
asmgen.translateNormalAssignment(assign)
src = AsmAssignSource.fromAstSource(s2, program, asmgen)
tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, null, variableAsmName = "prog8_lib.strcmp_expression._arg_s2")
assign = AsmAssignment(src, tgt, false, Position.DUMMY)
asmgen.translateNormalAssignment(assign)
asmgen.out(" jsr prog8_lib.strcmp_expression") // result of compare is in A asmgen.out(" jsr prog8_lib.strcmp_expression") // result of compare is in A
when(operator) { when(operator) {
"==" -> asmgen.out(" and #1 | eor #1 | sta P8ESTACK_LO,x") "==" -> asmgen.out(" and #1 | eor #1 | sta P8ESTACK_LO,x")

14
compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt
View File

@ -1289,4 +1289,18 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
} }
} }
} }
internal fun assignExpressionToRegister(expr: Expression, register: RegisterOrPair) {
val src = AsmAssignSource.fromAstSource(expr, program, asmgen)
val tgt = AsmAssignTarget.fromRegisters(register, null, program, asmgen)
val assign = AsmAssignment(src, tgt, false, expr.position)
translateNormalAssignment(assign)
}
internal fun assignExpressionToVariable(expr: Expression, asmVarName: String, dt: DataType, scope: Subroutine?) {
val src = AsmAssignSource.fromAstSource(expr, program, asmgen)
val tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, dt, scope, variableAsmName = asmVarName)
val assign = AsmAssignment(src, tgt, false, expr.position)
translateNormalAssignment(assign)
}
} }

8
examples/test.p8
View File

@ -1,11 +1,15 @@
%import textio %import textio
%zeropage basicsafe
main { main {
sub start() { sub start() {
; TODO breakpoint label is no longer outputted by 64tass ... str s1 = "irmen"
%breakpoint str s2 = "hello"
txt.print_ub(s1==s2)
txt.print_ub(s1!=s2)
testX() testX()
} }