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

   1 # 2016/08/13
   2
   3 ## 10:02
   4
   5 I will need to keep an eye out for division and remainder following each other
   6 in cases where the native architecture does both at the same time.
   7
   8 ## 21:26
   9
  10 `JITStaticCallRewrite` would likely be better if it just rewrote the actual
  11 used class, this would simplify the constant pool intialization and it would
  12 also have the effect of having the ability to have instances of changed
  13 classes also. So it renames all instances of a given class.
  14
  15 ## 21:40
  16
  17 I suppose in the simulated environment, for simplicity so that stuff such as
  18 field name collisions and such can be handled, for the most part just prepend
  19 a prefix to everything. Then to simplify handling of cases where one calls
  20 `hashCode()` and has a string called "hashCode", just duplicate every entry
  21 in the constant pool. Also, when it comes to `LDC` on a string in the constant
  22 pool, duplicate entries a third time for each string where `LDC` on strings is
  23 rewritten to something else. A problem however is that `ldc` is two bytes
  24 wide while `getstatic` is 3 bytes wide. So it cannot trivially be translated.
  25 Strings have to be rewritten however. There is also the case of string being
  26 rewritten to refer to itself also.
  27
  28 ## 21:52
  29
  30 Actually with just plain class rewrites, I do not need a wrapper class for the
  31 constant pool, so I can just use it directly as such. Before I would have
  32 needed to handle cases where a class is referred to and such. So just renaming
  33 the class simplifies things.
  34
  35 ## 22:09
  36
  37 Not sure if I want to write the pool first or later. Writing it I will need to
  38 know if there are any rewritten imports though.
  39
  40 ## 23:52
  41
  42 Although thinking about it, rewriting could only be enabled if the class name
  43 being rewritting is not itself. So if `Foo` is being rewritten to `Bar` then
  44 when `Foo` is processed, it will remain `Foo` and not become `Bar`.
  45
  46 ## 23:56
  47
  48 Then this means that, the constant pool can do rewrites now, which simplifies
  49 that.
  50