assets/developer-notes/stephanie-gawroriski/2016/08/19.mkd

   1 # 2016/08/19
   2
   3 ## 10:21
   4
   5 Looks like `__ClassDecoder__` is getting a bit big since it triggers the class
   6 size warning.
   7
   8 ## 11:25
   9
  10 I can perform some basic and minor optimizations by caching some stack values
  11 using a simple and naive means. When it comes to saving/restoring values I can
  12 just lazily allocate a bunch of stack items for the number of local and stack
  13 variables.
  14
  15 ## 13:52
  16
  17 So what I need is a generic class output system where I can write machine code
  18 into.
  19
  20 ## 13:54
  21
  22 I suppose for simplicity that the JIT will treat the stack and locals as a
  23 single unified set of registers. Registers can be translated to stack machines
  24 as needed. Personally Java should have just used registers from the start
  25 instead of using a stack machine. However, I just need an efficient stack
  26 cacher.
  27
  28 ## 15:12
  29
  30 Took a walk, was rather hot. However, I determined that a single straight
  31 through parsing can work but it would needlessly complicate how the JIT would
  32 work. There could be areas of code that `goto` to a later portion of code
  33 where I would have no idea what type of values are in variables, then that
  34 code could `goto` back to that unknown area. So I would need to defer handling.
  35 Then there are also exceptions and the stack map table to consider also.
  36 However, I already have a bunch of the code reading, exception handler parsing,
  37 and `StackMap` parsing code somewhere in history. I just need to find that
  38 history and then carefully import that code in.
  39
  40 ## 18:24
  41
  42 Ok, so I need to merge work from multiple revisions:
  43
  44  * `b3233946eb8b134705cd9bfbac9f459b9cef6ee8` (`byte-code`)
  45  * `173307290a537df61f99a5e240d32ee235e6b446` (`java-byte-code`)
  46  * `dd444e270199cdf9899c9699900a2638c5413312`
  47
  48 ## 20:17
  49
  50 So one thing to consider is...
  51
  52 ## 20:29
  53
  54 ...to keep the code simple. Before I had a complex cache system which was
  55 convoluted along with megaswitches and code all over the place for handling
  56 byte code operations. Since many operations are the same, I need to have a kind
  57 of simple dispatch that is not slow at all yet very simple. I suppose what I
  58 can do, like I have thought up of previously, have a kind of micro-op where
  59 instead of having clunky CISC like operations, they can be condensed into
  60 simple move operations and actual work operations.
  61