From 62b32b22110e94229d9fe7d89593159e8f94c73a Mon Sep 17 00:00:00 2001 From: Irmen de Jong Date: Sun, 3 Apr 2022 22:56:13 +0200 Subject: [PATCH] todos --- .../src/prog8/codegen/virtual/CodeGen.kt | 4 +- compiler/res/prog8lib/cx16/gfx2.p8 | 4 +- docs/source/todo.rst | 41 +++++++++++-------- examples/test.p8 | 1 + virtualmachine/src/prog8/vm/VirtualMachine.kt | 4 +- 5 files changed, 29 insertions(+), 25 deletions(-) diff --git a/codeGenVirtual/src/prog8/codegen/virtual/CodeGen.kt b/codeGenVirtual/src/prog8/codegen/virtual/CodeGen.kt index 38e0063f3..63a041be3 100644 --- a/codeGenVirtual/src/prog8/codegen/virtual/CodeGen.kt +++ b/codeGenVirtual/src/prog8/codegen/virtual/CodeGen.kt @@ -491,7 +491,7 @@ class CodeGen(internal val program: PtProgram, } private fun translate(assignment: PtAssignment): VmCodeChunk { - // TODO can in-place assignments (assignment.augmentable = true) be optimized more? + // TODO can in-place assignments be optimized more? val code = VmCodeChunk() val resultRegister = vmRegisters.nextFree() @@ -545,7 +545,7 @@ class CodeGen(internal val program: PtProgram, } private fun translate(sub: PtSub): VmCodeChunk { - // TODO actually inline subroutines marked as inline + // TODO actually inline subroutines marked as inline (but at this time only asmsub can be inline) val code = VmCodeChunk() code += VmCodeComment("SUB: ${sub.scopedName} -> ${sub.returntype}") code += VmCodeLabel(sub.scopedName) diff --git a/compiler/res/prog8lib/cx16/gfx2.p8 b/compiler/res/prog8lib/cx16/gfx2.p8 index 4aedd261e..519dffeb7 100644 --- a/compiler/res/prog8lib/cx16/gfx2.p8 +++ b/compiler/res/prog8lib/cx16/gfx2.p8 @@ -15,14 +15,12 @@ ; mode 1 = bitmap 320 x 240 monochrome ; mode 2 = bitmap 320 x 240 x 4c (TODO not yet implemented) ; mode 3 = bitmap 320 x 240 x 16c (TODO not yet implemented) -; mode 4 = bitmap 320 x 240 x 256c +; mode 4 = bitmap 320 x 240 x 256c (like SCREEN $80 but using this api instead of kernal) ; mode 5 = bitmap 640 x 480 monochrome ; mode 6 = bitmap 640 x 480 x 4c ; higher color dephts in highres are not supported due to lack of VRAM -; TODO can we make a FB vector table and emulation routines for the Cx16s' GRAPH_init() call? to replace the builtin 320x200 fb driver? - gfx2 { ; read-only control variables: diff --git a/docs/source/todo.rst b/docs/source/todo.rst index d0538187e..edd412786 100644 --- a/docs/source/todo.rst +++ b/docs/source/todo.rst @@ -3,15 +3,17 @@ TODO For next release ^^^^^^^^^^^^^^^^ -- vm codegen/assembler: variable memory locations should also be referenced by the variable name instead of just the address, to make the output more human-readable -- vm: make registers typed? so that it's immediately obvious what type they represent. Much like regular variables in memory. - so we have a set of byte registers, a set of word registers, and other sets if we introduce other types. -- vm: don't store symbol names in instructions to make optimizing the IR easier? but what about jumps to labels. And it's no longer readable by humans. -- vm: how to remove all unused subroutines? (in the assembly codegen, we let 64tass solve this for us) -- vm: rather than being able to jump to any 'address' (IPTR), use 'blocks' that have entry and exit points -> even better dead code elimination possible too -- when the vm is stable and *if* its language can get promoted to prog8 IL, the variable allocation should be changed. - It's now done before the vm code generation, but the IL should probably not depend on the allocations already performed. - So the CodeGen doesn't do VariableAlloc *before* the codegen, but as a last step. +- cx16 textio: optimize the 4 scroll routines and setcc/setcc2. +- vm: implement all operators in the virtualmachine +- vm: codegen: more optimal code for loops ending on 0 (BNZ?) +- pipe operator: allow non-unary function calls in the pipe that specify the other argument(s) in the calls. +- writeAssembly(): make it possible to actually get rid of the VarDecl nodes by fixing the rest of the code mentioned there. +- allow "xxx" * constexpr (where constexpr is not a number literal), now gives expression error not same type +- make it possible to inline non-asmsub routines that just contain a single statement (return, functioncall, assignment) + but this requires all identifiers in the inlined expression to be changed to fully scoped names. + If we can do that why not perhaps also able to inline multi-line subroutines? Why would it be limited to just 1 line? Maybe to protect against code size bloat. + Inlined subroutines cannot contain further nested subroutines! + Once this works, look for library subroutines that should be inlined. ... @@ -27,26 +29,29 @@ Future Things and Ideas ^^^^^^^^^^^^^^^^^^^^^^^ Compiler: +- vm: codegen: various TODOs to tweak code +- vm: expressionGen: various TODOs to tweak code +- vm: make registers typed? so that it's immediately obvious what type they represent. Much like regular variables in memory. + so we have a set of byte registers, a set of word registers, and other sets if we introduce other types. +- vm: don't store symbol names in instructions to make optimizing the IR easier? but what about jumps to labels. And it's no longer readable by humans. +- vm: how to remove all unused subroutines? (in the assembly codegen, we let 64tass solve this for us) +- vm: rather than being able to jump to any 'address' (IPTR), use 'blocks' that have entry and exit points -> even better dead code elimination possible too +- when the vm is stable and *if* its language can get promoted to prog8 IL, the variable allocation should be changed. + It's now done before the vm code generation, but the IL should probably not depend on the allocations already performed. + So the CodeGen doesn't do VariableAlloc *before* the codegen, but as a last step. - vm code gen: don't reuse registers and don't pre allocate variables? (except strings + arrays) but instead put them into registers too then we ALMOST have Static Single Assignment form in the VM code. But what can we use that for? -- pipe operator: allow non-unary function calls in the pipe that specify the other argument(s) in the calls. -- writeAssembly(): make it possible to actually get rid of the VarDecl nodes by fixing the rest of the code mentioned there. - make everything an expression? (get rid of Statements. Statements are expressions with void return types?). -- allow "xxx" * constexpr (where constexpr is not a number literal), now gives expression error not same type -- make it possible to inline non-asmsub routines that just contain a single statement (return, functioncall, assignment) - but this requires all identifiers in the inlined expression to be changed to fully scoped names. - If we can do that why not perhaps also able to inline multi-line subroutines? Why would it be limited to just 1 line? Maybe to protect against code bloat. - Inlined subroutines cannot contain further nested subroutines! - simplifyConditionalExpression() should not split expression if it still results in stack-based evaluation, but how does it know? - simplifyConditionalExpression() sometimes introduces needless assignment to r9 tempvar (scenario sought) -- consider adding McCarthy evaluation to shortcircuit and and or expressions. First do ifs by splitting them up? Then do expressions that compute a value? +- consider adding McCarthy evaluation to shortcircuit and/or expressions. First do ifs by splitting them up? Then do expressions that compute a value? - make it possible to use cpu opcodes such as 'nop' as variable names by prefixing all asm vars with something such as ``p8v_``? Or not worth it (most 3 letter opcodes as variables are nonsensical anyway) then we can get rid of the instruction lists in the machinedefinitions as well? - [problematic due to 64tass:] add a compiler option to not remove unused subroutines. this allows for building library programs. But this won't work with 64tass's .proc ... Perhaps replace all uses of .proc/.pend by .block/.bend will fix that? (but we lose the optimizing aspect of the assembler where it strips out unused code. There's not really a dynamic switch possible as all assembly lib code is static and uses one or the other) -- Zig-like try-based error handling where the V flag could indicate error condition? and/or BRK to jump into monitor on failure? (has to set BRK vector for this) + Zig-like try-based error handling where the V flag could indicate error condition? and/or BRK to jump into monitor on failure? (has to set BRK vector for that) - add special (u)word array type (or modifier?) that puts the array into memory as 2 separate byte-arrays 1 for LSB 1 for MSB -> allows for word arrays of length 256 Libraries: diff --git a/examples/test.p8 b/examples/test.p8 index 5fff06771..2521a433f 100644 --- a/examples/test.p8 +++ b/examples/test.p8 @@ -11,6 +11,7 @@ main { sub start() { txt.print_ub(global) global++ + rol2(global) ; a "pixelshader": ; syscall1(8, 0) ; enable lo res creen diff --git a/virtualmachine/src/prog8/vm/VirtualMachine.kt b/virtualmachine/src/prog8/vm/VirtualMachine.kt index d5e13f5e7..7cc15648f 100644 --- a/virtualmachine/src/prog8/vm/VirtualMachine.kt +++ b/virtualmachine/src/prog8/vm/VirtualMachine.kt @@ -588,7 +588,7 @@ class VirtualMachine(val memory: Memory, program: List) { if(right==0.toUByte()) 0xffu else left % right } - else -> TODO("operator $operator") + else -> TODO("operator byte $operator") } registers.setUB(reg1, result.toUByte()) } @@ -608,7 +608,7 @@ class VirtualMachine(val memory: Memory, program: List) { if(right==0.toUShort()) 0xffffu else left % right } - else -> TODO("operator $operator") + else -> TODO("operator word $operator") } registers.setUW(reg1, result.toUShort()) }