From 8a4979f44c3289f0c994e0d1e16abb657622ce90 Mon Sep 17 00:00:00 2001 From: Irmen de Jong Date: Sun, 29 Jan 2023 12:47:12 +0100 Subject: [PATCH] vm target 'zeropage' more robust --- .../target/virtual/VirtualMachineDefinition.kt | 17 ++++++++++++++++- .../src/prog8/codegen/cpu6502/Extensions.kt | 2 +- .../codegen/cpu6502/assignment/AsmAssignment.kt | 6 +++--- .../compiler/astprocessing/SymbolTableMaker.kt | 17 ++++++++++------- 4 files changed, 30 insertions(+), 12 deletions(-) diff --git a/codeCore/src/prog8/code/target/virtual/VirtualMachineDefinition.kt b/codeCore/src/prog8/code/target/virtual/VirtualMachineDefinition.kt index c4e0f144c..ab242ea68 100644 --- a/codeCore/src/prog8/code/target/virtual/VirtualMachineDefinition.kt +++ b/codeCore/src/prog8/code/target/virtual/VirtualMachineDefinition.kt @@ -44,9 +44,24 @@ class VirtualMachineDefinition: IMachineDefinition { override fun isIOAddress(address: UInt): Boolean = false - override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {} + override fun initializeMemoryAreas(compilerOptions: CompilationOptions) { + zeropage = VirtualZeropage(compilerOptions) + } } interface IVirtualMachineRunner { fun runProgram(irSource: String) } + +private class VirtualZeropage(options: CompilationOptions): Zeropage(options) { + override val SCRATCH_B1: UInt + get() = throw IllegalStateException("virtual shouldn't use this zeropage variable") + override val SCRATCH_REG: UInt + get() = throw IllegalStateException("virtual shouldn't use this zeropage variable") + override val SCRATCH_W1: UInt + get() = throw IllegalStateException("virtual shouldn't use this zeropage variable") + override val SCRATCH_W2: UInt + get() = throw IllegalStateException("virtual shouldn't use this zeropage variable") + + override fun allocateCx16VirtualRegisters() { /* there is no actual zero page in this target to allocate thing in */ } +} diff --git a/codeGenCpu6502/src/prog8/codegen/cpu6502/Extensions.kt b/codeGenCpu6502/src/prog8/codegen/cpu6502/Extensions.kt index 1067a6220..4e271d9d8 100644 --- a/codeGenCpu6502/src/prog8/codegen/cpu6502/Extensions.kt +++ b/codeGenCpu6502/src/prog8/codegen/cpu6502/Extensions.kt @@ -66,7 +66,7 @@ internal fun PtIdentifier.targetStatement(program: PtProgram): PtNode { } internal fun PtProgram.lookup(name: String): PtNode { - val remainder = name.split('.').toMutableList() + val remainder = name.split('.').toMutableList() // TODO optimize split to not use memory allocations fun recurse(node: PtNode): PtNode { when(node) { diff --git a/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AsmAssignment.kt b/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AsmAssignment.kt index 93a278a82..6556d9a3e 100644 --- a/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AsmAssignment.kt +++ b/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AsmAssignment.kt @@ -55,7 +55,7 @@ internal class AsmAssignTarget(val kind: TargetStorageKind, when { identifier != null -> { val paramName = identifier!!.targetVarDecl(program)?.name - val parameter = identifier!!.targetStatement(program)?.definingSub()?.parameters?.singleOrNull { it.name===paramName } + val parameter = identifier!!.targetStatement(program).definingSub()?.parameters?.singleOrNull { it.name===paramName } println("assign to ${identifier!!.name} param=$parameter") // TODO WEG if (parameter!=null) { val sub = parameter.definingAsmSub() @@ -131,12 +131,12 @@ internal class AsmAssignSource(val kind: SourceStorageKind, return AsmAssignSource(SourceStorageKind.LITERALNUMBER, program, asmgen, cv.type, number = cv) return when(value) { - is PtNumber -> throw AssemblyError("should have been constant value") + // checked above: is PtNumber -> throw AssemblyError("should have been constant value") is PtString -> throw AssemblyError("string literal value should not occur anymore for asm generation") is PtArray -> throw AssemblyError("array literal value should not occur anymore for asm generation") is PtIdentifier -> { val paramName = value.targetVarDecl(program)?.name - val parameter = value.targetStatement(program)?.definingSub()?.parameters?.singleOrNull { it.name===paramName } + val parameter = value.targetStatement(program).definingSub()?.parameters?.singleOrNull { it.name===paramName } println("assign to ${value.name} param=$parameter") // TODO WEG if(parameter?.definingAsmSub() != null) throw AssemblyError("can't assign from a asmsub register parameter $value ${value.position}") diff --git a/compiler/src/prog8/compiler/astprocessing/SymbolTableMaker.kt b/compiler/src/prog8/compiler/astprocessing/SymbolTableMaker.kt index 9e412db3e..e4b3b661e 100644 --- a/compiler/src/prog8/compiler/astprocessing/SymbolTableMaker.kt +++ b/compiler/src/prog8/compiler/astprocessing/SymbolTableMaker.kt @@ -10,6 +10,7 @@ import prog8.code.core.ArrayDatatypes import prog8.code.core.CompilationOptions import prog8.code.core.DataType import prog8.code.core.Position +import prog8.code.target.VMTarget import java.util.* internal class SymbolTableMaker(private val program: Program, private val options: CompilationOptions): IAstVisitor { @@ -29,13 +30,15 @@ internal class SymbolTableMaker(private val program: Program, private val option } require(scopestack.isEmpty()) - // add the hardcoded temporary zeropage variables - st.add(StMemVar("P8ZP_SCRATCH_B1", DataType.UBYTE, options.compTarget.machine.zeropage.SCRATCH_B1, null, Position.DUMMY)) - st.add(StMemVar("P8ZP_SCRATCH_REG", DataType.UBYTE, options.compTarget.machine.zeropage.SCRATCH_REG, null, Position.DUMMY)) - st.add(StMemVar("P8ZP_SCRATCH_W1", DataType.UWORD, options.compTarget.machine.zeropage.SCRATCH_W1, null, Position.DUMMY)) - st.add(StMemVar("P8ZP_SCRATCH_W2", DataType.UWORD, options.compTarget.machine.zeropage.SCRATCH_W2, null, Position.DUMMY)) - st.add(StMemVar("P8ESTACK_LO", DataType.UBYTE, options.compTarget.machine.ESTACK_LO, null, Position.DUMMY)) - st.add(StMemVar("P8ESTACK_HI", DataType.UBYTE, options.compTarget.machine.ESTACK_HI, null, Position.DUMMY)) + if(options.compTarget.name!=VMTarget.NAME) { + // add the hardcoded temporary zeropage variables for targets that use them + st.add(StMemVar("P8ZP_SCRATCH_B1", DataType.UBYTE, options.compTarget.machine.zeropage.SCRATCH_B1, null, Position.DUMMY)) + st.add(StMemVar("P8ZP_SCRATCH_REG", DataType.UBYTE, options.compTarget.machine.zeropage.SCRATCH_REG, null, Position.DUMMY)) + st.add(StMemVar("P8ZP_SCRATCH_W1", DataType.UWORD, options.compTarget.machine.zeropage.SCRATCH_W1, null, Position.DUMMY)) + st.add(StMemVar("P8ZP_SCRATCH_W2", DataType.UWORD, options.compTarget.machine.zeropage.SCRATCH_W2, null, Position.DUMMY)) + st.add(StMemVar("P8ESTACK_LO", DataType.UBYTE, options.compTarget.machine.ESTACK_LO, null, Position.DUMMY)) + st.add(StMemVar("P8ESTACK_HI", DataType.UBYTE, options.compTarget.machine.ESTACK_HI, null, Position.DUMMY)) + } return st }