assets/developer-notes/stephanie-gawroriski/2019/03/22.mkd

   1 # 2019/03/22
   2
   3 ## 09:05
   4
   5 I am going to need a jumping point for the exception handler table. Like, I
   6 am going to have to handle uncounting on the stack for any references that
   7 exist before jumping to an exception handler. Local variables generally are
   8 not cleared at all, except in the case where the target jump address has no
   9 locals defined there (that is objects can turn into nothing). So there would
  10 have to be locals and stack states, the exception handlers would need to
  11 uncount any locals which are cleared out. So this means that we cannot have
  12 an intermediate uncounter and jump to a generic table, the state of the
  13 locals and stack is unique to the target. However, two different instructions
  14 with the same object set states will of course use the same table.
  15
  16 ## 09:11
  17
  18 Actually I do not even need to use temporary code builders, I can just store
  19 the unique combinations in the table and worry about it at the end.
  20
  21 ## 09:55
  22
  23 I really like the idea of dedicated registers and instructions for exceptions
  24 and return values. This makes it so I do not need to jumble them with the main
  25 set of registers. Also returning is easy because these registers are global
  26 per thread. It just overall simplifies things greatly.
  27
  28 ## 13:28
  29
  30 I see areas of return being a spot with a high potential of duplicate code
  31 when the return is being done. So like the exception stuff I am going to make
  32 it so that are condensed with returning points and such.
  33
  34 ## 13:43
  35
  36 Another trick I can do to minimize code, is that if there is no exception
  37 handlers defined then I can just do a return with the entire stack and
  38 return point. Going up the stack has the same result as a return in this case.
  39
  40 ## 14:24
  41
  42 I figured out how I can do stack caching, well basic stack caching at least
  43 with arguments passed to a method. I can just scan every instruction and flag
  44 ones which write to a local. Any local which is not written to is considered
  45 final and can be cached when used. This also means I have to turn invokes into
  46 register lists for the arguments.
  47
  48 ## 15:40
  49
  50 I can also optimize the JUMP_ON_EXCEPTION when it comes to default handlers
  51 with no exceptions to actually handle. They can just jump to one of the return
  52 points by overridding a label.
  53
  54 ## 18:24
  55
  56 Okay so, I managed to remove useless jumps which means that the code that just
  57 calls the other constructors is very simple.