assets/developer-notes/stephanie-gawroriski/2022/09/06.mkd

   1 # 2022/09/06
   2
   3 ## 14:46
   4
   5 Okay so for compilation I have two ideas: returning compiled class reference
   6 and
   7 a bigger one that is register handling. So I will have two classes of registers
   8 which are either `int` or `object`. Any floating point and long will be done
   9 with the software math libraries. There will be a later stack caching pipeline
  10 but on the first stage there will be no stack caching, this is so the first
  11 stage can be made simpler and I can add stack caching later on accordingly.
  12 At least then if I can make it so that register operations and otherwise are
  13 more simple. I should probably have explicit outputs for instructions and
  14 such rather than just none of that. There will be a special instruction called
  15 `drop` which will just mark a register as invalid, could be used by the stack
  16 cached stage. Also perhaps as well I should do unique registers and whatnot so
  17 that no registers are actually used and they all have sources, but they do have
  18 dependencies. Will see how it works, but it would simplify the later stack
  19 caching stage where dependencies are known. So like every value in a register
  20 will be transformed by previous instructions and otherwise so that way
  21 everything is essentially just a long list of past values. Then if a value
  22 is replaced of course that history is deleted. This would produce a very large
  23 number of registers but each one would be unique and have a formula that
  24 actually creates them. At least for the stack caching stage it could make it
  25 easier to do. I would also have to keep track of whether a value is a mutate
  26 or is bound to a specific range, for example to cache out `null` checks. So
  27 yeah each stage of instruction will track whether a register is `MUTATED`,
  28 `COPIED`, or `LIMITED_VALUE`.