From 59a2fec176ec23e6ff1ecd3a7e241eeb85214864 Mon Sep 17 00:00:00 2001 From: Irmen de Jong Date: Sun, 8 Sep 2024 21:49:13 +0200 Subject: [PATCH] fix IR containment check --- .../codegen/intermediate/BuiltinFuncGen.kt | 1 + .../codegen/intermediate/ExpressionGen.kt | 4 +++ docs/source/todo.rst | 3 ++ examples/test.p8 | 34 +++++++++++++++++-- 4 files changed, 40 insertions(+), 2 deletions(-) diff --git a/codeGenIntermediate/src/prog8/codegen/intermediate/BuiltinFuncGen.kt b/codeGenIntermediate/src/prog8/codegen/intermediate/BuiltinFuncGen.kt index 88d2098b8..119b4dc35 100644 --- a/codeGenIntermediate/src/prog8/codegen/intermediate/BuiltinFuncGen.kt +++ b/codeGenIntermediate/src/prog8/codegen/intermediate/BuiltinFuncGen.kt @@ -580,6 +580,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe val arr = (arg as? PtArrayIndexer) val index = arr?.index?.asConstInteger() if(arr!=null && index!=null) { + if(arr.splitWords) TODO("IR rol/ror on split words array") val variable = arr.variable.name val itemsize = codeGen.program.memsizer.memorySize(arr.type) addInstr(result, IRInstruction(opcodeMemAndReg.first, vmDt, labelSymbol = variable, symbolOffset = index*itemsize), null) diff --git a/codeGenIntermediate/src/prog8/codegen/intermediate/ExpressionGen.kt b/codeGenIntermediate/src/prog8/codegen/intermediate/ExpressionGen.kt index 35872c49f..9218d4bfe 100644 --- a/codeGenIntermediate/src/prog8/codegen/intermediate/ExpressionGen.kt +++ b/codeGenIntermediate/src/prog8/codegen/intermediate/ExpressionGen.kt @@ -177,6 +177,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) { val iterableTr = translateExpression(check.iterable) addToResult(result, iterableTr, iterableTr.resultReg, -1) result += codeGen.makeSyscall(IMSyscall.STRING_CONTAINS, listOf(IRDataType.BYTE to elementTr.resultReg, IRDataType.WORD to iterableTr.resultReg), IRDataType.BYTE to elementTr.resultReg) + addInstr(result, IRInstruction(Opcode.CMPI, IRDataType.BYTE, reg1=elementTr.resultReg, immediate = 0), null) return ExpressionCodeResult(result, IRDataType.BYTE, elementTr.resultReg, -1) } DataType.ARRAY_UB, DataType.ARRAY_B -> { @@ -189,6 +190,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) { val iterableLength = codeGen.symbolTable.getLength(check.iterable.name) addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=lengthReg, immediate = iterableLength!!), null) result += codeGen.makeSyscall(IMSyscall.BYTEARRAY_CONTAINS, listOf(IRDataType.BYTE to elementTr.resultReg, IRDataType.WORD to iterableTr.resultReg, IRDataType.BYTE to lengthReg), IRDataType.BYTE to elementTr.resultReg) + addInstr(result, IRInstruction(Opcode.CMPI, IRDataType.BYTE, reg1=elementTr.resultReg, immediate = 0), null) return ExpressionCodeResult(result, IRDataType.BYTE, elementTr.resultReg, -1) } DataType.ARRAY_UW, DataType.ARRAY_W -> { @@ -201,6 +203,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) { val iterableLength = codeGen.symbolTable.getLength(check.iterable.name) addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=lengthReg, immediate = iterableLength!!), null) result += codeGen.makeSyscall(IMSyscall.WORDARRAY_CONTAINS, listOf(IRDataType.WORD to elementTr.resultReg, IRDataType.WORD to iterableTr.resultReg, IRDataType.BYTE to lengthReg), IRDataType.BYTE to elementTr.resultReg) + addInstr(result, IRInstruction(Opcode.CMPI, IRDataType.BYTE, reg1=elementTr.resultReg, immediate = 0), null) return ExpressionCodeResult(result, IRDataType.BYTE, elementTr.resultReg, -1) } DataType.ARRAY_F -> { @@ -214,6 +217,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) { val iterableLength = codeGen.symbolTable.getLength(check.iterable.name) addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=lengthReg, immediate = iterableLength!!), null) result += codeGen.makeSyscall(IMSyscall.FLOATARRAY_CONTAINS, listOf(IRDataType.FLOAT to elementTr.resultFpReg, IRDataType.WORD to iterableTr.resultReg, IRDataType.BYTE to lengthReg), IRDataType.BYTE to resultReg) + addInstr(result, IRInstruction(Opcode.CMPI, IRDataType.BYTE, reg1=resultReg, immediate = 0), null) return ExpressionCodeResult(result, IRDataType.BYTE, resultReg, -1) } else -> throw AssemblyError("weird iterable dt ${check.iterable.type} for ${check.iterable.name}") diff --git a/docs/source/todo.rst b/docs/source/todo.rst index 181a4fc9c..b44c9a529 100644 --- a/docs/source/todo.rst +++ b/docs/source/todo.rst @@ -1,6 +1,9 @@ TODO ==== +Main branch: possible optimization for: if x < 2/ x<1 -> if x==0 or x==1 likewise for > 253/ >254 + + Improve register load order in subroutine call args assignments: in certain situations, the "wrong" order of evaluation of function call arguments is done which results in overwriting registers that already got their value, which requires a lot of stack juggling (especially on plain 6502 cpu!) diff --git a/examples/test.p8 b/examples/test.p8 index 1d6aeadfe..6660a3ba2 100644 --- a/examples/test.p8 +++ b/examples/test.p8 @@ -1,10 +1,40 @@ %import textio - %zeropage basicsafe %option no_sysinit main { sub start() { - txt.print_bool(cx16.mouse_present()) + ubyte @shared x + uword @shared w + + x=2 + if x==2 or cx16.r0L==42 + txt.print("yep0\n") + + if x==1 or x==2 + txt.print("yep1\n") + + x = 9 + if x==1 or x==2 + txt.print("yep2-shouldn't-see-this\n") ; TODO fix this in IR/VM + + if x in 1 to 4 + txt.print("yep3-shouldn't-see-this\n") + if x in 4 to 10 + txt.print("yep4\n") + + + w=2222 + if w==1111 or w==2222 + txt.print("w-yep1\n") + + w = 4999 + if w==1111 or w==2222 + txt.print("w-yep2-shouldn't-see-this\n") ; TODO fix this in IR/VM + + if w in 1111 to 4444 + txt.print("w-yep3-shouldn't-see-this\n") + if w in 4444 to 5555 + txt.print("w-yep4\n") } }