preparing to support assignment to indexed pointer targets

Author: irmen

codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AsmAssignment.kt

@@ -91,6 +91,7 @@ internal class AsmAssignTarget(val kind: TargetStorageKind,
                     array != null -> return AsmAssignTarget(TargetStorageKind.ARRAY, asmgen, type, definingSub, target.position, array = array, origAstTarget =  this)
                     memory != null -> return AsmAssignTarget(TargetStorageKind.MEMORY, asmgen, type, definingSub, target.position, memory =  memory, origAstTarget =  this)
                     pointerDeref != null -> return AsmAssignTarget(TargetStorageKind.POINTER, asmgen, type, definingSub, target.position, pointer = pointerDeref, origAstTarget =  this)
+                    indexedPointerDeref != null -> TODO("assign to indexed pointer  ${target.position} - for now, split up the assignment target using a temporary pointer variable")
                     else -> throw AssemblyError("weird target")
                 }
             }

codeGenIntermediate/src/prog8/codegen/intermediate/AssignmentGen.kt

@@ -463,10 +463,6 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
 
     private fun translateRegularAssign(assignment: PtAssignment): IRCodeChunks {
         // note: assigning array and string values is done via an explicit memcopy/stringcopy function call.
-        val targetIdent = assignment.target.identifier
-        val targetMemory = assignment.target.memory
-        val targetArray = assignment.target.array
-        val targetPointerDeref = assignment.target.pointerDeref
         val valueDt = irType(assignment.value.type)
         val targetDt = irType(assignment.target.type)
         val result = mutableListOf<IRCodeChunkBase>()
@@ -507,98 +503,107 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
             }
         }
 
-        if(targetIdent!=null) {
-            val instruction = if(zero) {
-                IRInstruction(Opcode.STOREZM, targetDt, labelSymbol = targetIdent.name)
-            } else {
-                if (targetDt == IRDataType.FLOAT) {
-                    require(valueFpRegister>=0)
-                    IRInstruction(Opcode.STOREM, targetDt, fpReg1 = valueFpRegister, labelSymbol = targetIdent.name)
-                }
-                else {
-                    require(valueRegister>=0)
-                    IRInstruction(Opcode.STOREM, targetDt, reg1 = valueRegister, labelSymbol = targetIdent.name)
-                }
-            }
-            result += IRCodeChunk(null, null).also { it += instruction }
-            return result
-        }
-        else if(targetArray!=null) {
-            val eltSize = codeGen.program.memsizer.memorySize(targetArray.type, null)
-            val variable = targetArray.variable
-            if(variable==null)
-                translateRegularAssignPointerIndexed(result, targetArray.pointerderef!!, eltSize, targetArray, zero, targetDt, valueRegister, valueFpRegister)
-            else if(variable.type.isPointer)
-                assignToIndexedSimplePointer(result, variable, eltSize, targetArray, zero, targetDt, valueRegister, valueFpRegister)
-            else
-                translateRegularAssignArrayIndexed(result, variable.name, eltSize, targetArray, zero, targetDt, valueRegister, valueFpRegister)
-            return result
-        }
-        else if(targetMemory!=null) {
-            require(targetDt == IRDataType.BYTE) { "must be byte type ${targetMemory.position}"}
-            if(zero) {
-                if(targetMemory.address is PtNumber) {
-                    val chunk = IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREZM, targetDt, address = (targetMemory.address as PtNumber).number.toInt()) }
-                    result += chunk
-                } else {
-                    val tr = expressionEval.translateExpression(targetMemory.address)
-                    val addressReg = tr.resultReg
-                    addToResult(result, tr, tr.resultReg, -1)
-                    result += IRCodeChunk(null, null).also {
-                        it += IRInstruction(Opcode.STOREZI, targetDt, reg1=addressReg)
+        with(assignment.target) {
+            when {
+                identifier != null -> {
+                    val instruction = if(zero) {
+                        IRInstruction(Opcode.STOREZM, targetDt, labelSymbol = identifier!!.name)
+                    } else {
+                        if (targetDt == IRDataType.FLOAT) {
+                            require(valueFpRegister>=0)
+                            IRInstruction(Opcode.STOREM, targetDt, fpReg1 = valueFpRegister, labelSymbol = identifier!!.name)
+                        }
+                        else {
+                            require(valueRegister>=0)
+                            IRInstruction(Opcode.STOREM, targetDt, reg1 = valueRegister, labelSymbol = identifier!!.name)
+                        }
                     }
-                }
-            } else {
-                val constAddress = targetMemory.address as? PtNumber
-                if(constAddress!=null) {
-                    addInstr(result, IRInstruction(Opcode.STOREM, targetDt, reg1=valueRegister, address=constAddress.number.toInt()), null)
+                    result += IRCodeChunk(null, null).also { it += instruction }
                     return result
                 }
-                val ptrWithOffset = targetMemory.address as? PtBinaryExpression
-                if(ptrWithOffset!=null) {
-                    if(ptrWithOffset.operator=="+" && ptrWithOffset.left is PtIdentifier) {
-                        val constOffset = (ptrWithOffset.right as? PtNumber)?.number?.toInt()
-                        if(constOffset in 0..255) {
-                            val ptrName = (ptrWithOffset.left as PtIdentifier).name
-                            val pointerReg = codeGen.registers.next(IRDataType.WORD)
+                memory != null -> {
+                    require(targetDt == IRDataType.BYTE) { "must be byte type ${memory!!.position}"}
+                    if(zero) {
+                        if(memory!!.address is PtNumber) {
+                            val chunk = IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREZM, targetDt, address = (memory!!.address as PtNumber).number.toInt()) }
+                            result += chunk
+                        } else {
+                            val tr = expressionEval.translateExpression(memory!!.address)
+                            val addressReg = tr.resultReg
+                            addToResult(result, tr, tr.resultReg, -1)
                             result += IRCodeChunk(null, null).also {
-                                it += IRInstruction(Opcode.LOADM, IRDataType.WORD, reg1=pointerReg, labelSymbol = ptrName)
-                                it += IRInstruction(Opcode.STOREFIELD, IRDataType.BYTE, reg1=valueRegister, reg2=pointerReg, immediate = constOffset)
+                                it += IRInstruction(Opcode.STOREZI, targetDt, reg1=addressReg)
                             }
+                        }
+                    } else {
+                        val constAddress = memory!!.address as? PtNumber
+                        if(constAddress!=null) {
+                            addInstr(result, IRInstruction(Opcode.STOREM, targetDt, reg1=valueRegister, address=constAddress.number.toInt()), null)
                             return result
                         }
-                    }
-                    val offsetTypecast = ptrWithOffset.right as? PtTypeCast
-                    if(ptrWithOffset.operator=="+" && ptrWithOffset.left is PtIdentifier && (ptrWithOffset.right.type.isByte || offsetTypecast?.value?.type?.isByte==true)) {
-                        // STOREIX only works with byte index.
-                        val tr = if(offsetTypecast?.value?.type?.isByte==true)
-                            expressionEval.translateExpression(offsetTypecast.value)
-                        else
-                            expressionEval.translateExpression(ptrWithOffset.right)
+                        val ptrWithOffset = memory!!.address as? PtBinaryExpression
+                        if(ptrWithOffset!=null) {
+                            if(ptrWithOffset.operator=="+" && ptrWithOffset.left is PtIdentifier) {
+                                val constOffset = (ptrWithOffset.right as? PtNumber)?.number?.toInt()
+                                if(constOffset in 0..255) {
+                                    val ptrName = (ptrWithOffset.left as PtIdentifier).name
+                                    val pointerReg = codeGen.registers.next(IRDataType.WORD)
+                                    result += IRCodeChunk(null, null).also {
+                                        it += IRInstruction(Opcode.LOADM, IRDataType.WORD, reg1=pointerReg, labelSymbol = ptrName)
+                                        it += IRInstruction(Opcode.STOREFIELD, IRDataType.BYTE, reg1=valueRegister, reg2=pointerReg, immediate = constOffset)
+                                    }
+                                    return result
+                                }
+                            }
+                            val offsetTypecast = ptrWithOffset.right as? PtTypeCast
+                            if(ptrWithOffset.operator=="+" && ptrWithOffset.left is PtIdentifier && (ptrWithOffset.right.type.isByte || offsetTypecast?.value?.type?.isByte==true)) {
+                                // STOREIX only works with byte index.
+                                val tr = if(offsetTypecast?.value?.type?.isByte==true)
+                                    expressionEval.translateExpression(offsetTypecast.value)
+                                else
+                                    expressionEval.translateExpression(ptrWithOffset.right)
+                                addToResult(result, tr, tr.resultReg, -1)
+                                val ptrName = (ptrWithOffset.left as PtIdentifier).name
+                                addInstr(result, IRInstruction(Opcode.STOREIX, IRDataType.BYTE, reg1=valueRegister, reg2=tr.resultReg, labelSymbol = ptrName), null)
+                                return result
+                            }
+                        }
+
+                        val tr = expressionEval.translateExpression(memory!!.address)
+                        val addressReg = tr.resultReg
                         addToResult(result, tr, tr.resultReg, -1)
-                        val ptrName = (ptrWithOffset.left as PtIdentifier).name
-                        addInstr(result, IRInstruction(Opcode.STOREIX, IRDataType.BYTE, reg1=valueRegister, reg2=tr.resultReg, labelSymbol = ptrName), null)
+                        addInstr(result, IRInstruction(Opcode.STOREI, targetDt, reg1=valueRegister, reg2=addressReg), null)
                         return result
                     }
+
+                    return result
                 }
+                array != null -> {
+                    val eltSize = codeGen.program.memsizer.memorySize(array!!.type, null)
+                    val variable = array!!.variable
+                    if(variable==null)
+                        translateRegularAssignPointerIndexed(result, array!!.pointerderef!!, eltSize, array!!, zero, targetDt, valueRegister, valueFpRegister)
+                    else if(variable.type.isPointer)
+                        assignToIndexedSimplePointer(result, variable, eltSize, array!!, zero, targetDt, valueRegister, valueFpRegister)
+                    else
+                        translateRegularAssignArrayIndexed(result, variable.name, eltSize, array!!, zero, targetDt, valueRegister, valueFpRegister)
+                    return result
+                }
+                pointerDeref != null -> {
+                    val (addressReg, offset) = codeGen.evaluatePointerAddressIntoReg(result, pointerDeref!!)
+                    val actualValueReg = if(pointerDeref!!.type.isFloat) valueFpRegister else valueRegister
+                    codeGen.storeValueAtPointersLocation(result, addressReg, offset, pointerDeref!!.type, zero, actualValueReg)
+                    return result
 
-                val tr = expressionEval.translateExpression(targetMemory.address)
-                val addressReg = tr.resultReg
-                addToResult(result, tr, tr.resultReg, -1)
-                addInstr(result, IRInstruction(Opcode.STOREI, targetDt, reg1=valueRegister, reg2=addressReg), null)
-                return result
+                }
+                indexedPointerDeref != null -> {
+                    TODO("assign to indexed pointer  ${assignment.target.position} - for now, split up the assignment target using a temporary pointer variable")
+                }
+                else -> {
+                    throw AssemblyError("weird assigntarget")
+                }
             }
-
-            return result
         }
-        else if(targetPointerDeref!=null) {
-            val (addressReg, offset) = codeGen.evaluatePointerAddressIntoReg(result, targetPointerDeref)
-            val actualValueReg = if(targetPointerDeref.type.isFloat) valueFpRegister else valueRegister
-            codeGen.storeValueAtPointersLocation(result, addressReg, offset, targetPointerDeref.type, zero, actualValueReg)
-            return result
-        }
-        else
-            throw AssemblyError("weird assigntarget")
     }
 
     private fun assignToIndexedSimplePointer(

codeGenIntermediate/src/prog8/codegen/intermediate/ExpressionGen.kt

@@ -88,6 +88,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
             is PtFunctionCall -> translate(expr)
             is PtContainmentCheck -> translate(expr)
             is PtPointerDeref -> translate(expr)
+            is PtArrayIndexedPointerDeref -> TODO("translate array indexed pointer deref expression $expr")
             is PtRange,
             is PtArray,
             is PtString -> throw AssemblyError("range/arrayliteral/string should no longer occur as expression")

codeOptimizers/src/prog8/optimizer/ConstantIdentifierReplacer.kt

@@ -28,17 +28,13 @@ class VarConstantValueTypeAdjuster(
         if(decl.parent is AnonymousScope)
             throw FatalAstException("vardecl may no longer occur in anonymousscope ${decl.position}")
 
-        try {
-            val declConstValue = decl.value?.constValue(program)
-            if(declConstValue!=null && (decl.type== VarDeclType.VAR || decl.type==VarDeclType.CONST)
-                && declConstValue.type != decl.datatype.base) {
-                if(decl.datatype.isInteger && declConstValue.type == BaseDataType.FLOAT) {
-                    // avoid silent float roundings
-                    errors.err("refused truncating of float to avoid loss of precision", decl.value!!.position)
-                }
+        val declConstValue = decl.value?.constValue(program)
+        if(declConstValue!=null && (decl.type== VarDeclType.VAR || decl.type==VarDeclType.CONST)
+            && declConstValue.type != decl.datatype.base) {
+            if(decl.datatype.isInteger && declConstValue.type == BaseDataType.FLOAT) {
+                // avoid silent float roundings
+                errors.err("refused truncating of float to avoid loss of precision", decl.value!!.position)
             }
-        } catch (x: UndefinedSymbolError) {
-            errors.err(x.message, x.position)
         }
 
         // replace variables by constants, if possible
@@ -313,41 +309,36 @@ internal class ConstantIdentifierReplacer(
         if(!dt.isKnown || !dt.isNumeric && !dt.isBool)
             return noModifications
 
-        try {
-            val cval = identifier.constValue(program) ?: return noModifications
-            val arrayIdx = identifier.parent as? ArrayIndexedExpression
-            if(arrayIdx!=null && cval.type.isNumeric) {
-                // special case when the identifier is used as a pointer var
-                // var = constpointer[x] --> var = @(constvalue+x) [directmemoryread]
-                // constpointer[x] = var -> @(constvalue+x) [directmemorywrite] = var
-                val add = BinaryExpression(NumericLiteral(cval.type, cval.number, identifier.position), "+", arrayIdx.indexer.indexExpr, identifier.position)
-                return if(arrayIdx.parent is AssignTarget) {
-                    val memwrite = DirectMemoryWrite(add, identifier.position)
-                    val assignTarget = AssignTarget(null, null, memwrite, null, false, position = identifier.position)
-                    listOf(IAstModification.ReplaceNode(arrayIdx.parent, assignTarget, arrayIdx.parent.parent))
-                } else {
-                    val memread = DirectMemoryRead(add, identifier.position)
-                    listOf(IAstModification.ReplaceNode(arrayIdx, memread, arrayIdx.parent))
-                }
+        val cval = identifier.constValue(program) ?: return noModifications
+        val arrayIdx = identifier.parent as? ArrayIndexedExpression
+        if(arrayIdx!=null && cval.type.isNumeric) {
+            // special case when the identifier is used as a pointer var
+            // var = constpointer[x] --> var = @(constvalue+x) [directmemoryread]
+            // constpointer[x] = var -> @(constvalue+x) [directmemorywrite] = var
+            val add = BinaryExpression(NumericLiteral(cval.type, cval.number, identifier.position), "+", arrayIdx.indexer.indexExpr, identifier.position)
+            return if(arrayIdx.parent is AssignTarget) {
+                val memwrite = DirectMemoryWrite(add, identifier.position)
+                val assignTarget = AssignTarget(null, null, memwrite, null, false, position = identifier.position)
+                listOf(IAstModification.ReplaceNode(arrayIdx.parent, assignTarget, arrayIdx.parent.parent))
+            } else {
+                val memread = DirectMemoryRead(add, identifier.position)
+                listOf(IAstModification.ReplaceNode(arrayIdx, memread, arrayIdx.parent))
             }
-            when {
-                cval.type.isNumericOrBool -> {
-                    if(parent is AddressOf)
-                        return noModifications      // cannot replace the identifier INSIDE the addr-of here, let's do it later.
-                    return listOf(
-                        IAstModification.ReplaceNode(
-                            identifier,
-                            NumericLiteral(cval.type, cval.number, identifier.position),
-                            identifier.parent
-                        )
+        }
+        when {
+            cval.type.isNumericOrBool -> {
+                if(parent is AddressOf)
+                    return noModifications      // cannot replace the identifier INSIDE the addr-of here, let's do it later.
+                return listOf(
+                    IAstModification.ReplaceNode(
+                        identifier,
+                        NumericLiteral(cval.type, cval.number, identifier.position),
+                        identifier.parent
                     )
-                }
-                cval.type.isPassByRef -> throw InternalCompilerException("pass-by-reference type should not be considered a constant")
-                else -> return noModifications
+                )
             }
-        } catch (x: UndefinedSymbolError) {
-            errors.err(x.message, x.position)
-            return noModifications
+            cval.type.isPassByRef -> throw InternalCompilerException("pass-by-reference type should not be considered a constant")
+            else -> return noModifications
         }
     }