assets/developer-notes/stephanie-gawroriski/2014/11/26.mkd

   1 # 2014/11/26
   2
   3 ***DISCLAIMER***: _These notes are from the defunct k8 project which_
   4 _precedes SquirrelJME. The notes for SquirrelJME start on 2016/02/26!_
   5 _The k8 project was effectively a Java SE 8 operating system and as such_
   6 _all of the notes are in the context of that scope. That project is no_
   7 _longer my goal as SquirrelJME is the spiritual successor to it._
   8
   9 ## 21:15
  10
  11 I took the day off coding, needed a break.
  12
  13 ## 21:28
  14
  15 I believe I was over complicating things before, I planned for this giant SSA
  16 based system where I could use it to write my compiler in the future but that
  17 would be much work, lots of work. I might now just translate the stack based
  18 machine to a register one, optimize it a bit, then just turn that into machine
  19 code and such. Although later I could just use the existing code since I will
  20 be compiling Java code anyway, so it does not really matter then. I would not
  21 have fancy encoders and decoders to translate back and forth from other
  22 machine languages, but oh well. This solution should be far simpler and easier
  23 to implement, although translating the stack based Java to a purely register
  24 based one may be a bit tricky, it should be easier than recreating a new SSA
  25 language to do something similar. Also going to cache the entire cache pool
  26 when work is done on that, to make things much easier when referencing
  27 everything in it.
  28
  29 ## 22:05
  30
  31 Now when linking, I can easily handle both classes and interfaces. Invoke of
  32 class methods is easy as I can just request a direct pointer to the method in
  33 it when linking is performed (it gets placed on the table). However interfaces
  34 get a bit more complex. So I think rather than having the code depend
  35 completely on whether something is an interface, the linker will create code
  36 that acts as an interface callsite, similar to invokedynamic I guess. So
  37 initially a reference to another method (if it has not been determined yet)
  38 would be a lazy call area anyway. That is the introductary linking area if the
  39 symbols are not currently available will link to a bridge method. And that
  40 bridge method will find the specified classes and then link them into all the
  41 other classes and replace their call sites. That might be too much work
  42 though, so if something is lazilly bound I can just keep calling the lazy
  43 execute and then when anything is called it just gets linked as it is called
  44 rather than sweeping through every loaded class everytime a class loads.
  45 However, when an interface is linked in since its location is unknown for any
  46 object that gets called that must determined at runtime. And since that would
  47 pollute the actual method. Actually, there is invokeinterface so I really do
  48 not have to worry about such things and in the invokeinterface case I can just
  49 have the interface handling code right there. To handle synchronized, I can
  50 just have it so the call site remains and it does a monitor wrap as needed
  51 without cluttering up the native code. If an interface implements another
  52 interface then it will just have those additional methods on its table.
  53