assets/developer-notes/stephanie-gawroriski/2016/09/14.mkd

   1 # 2016/09/14
   2
   3 ## 07:19
   4
   5 Thinking that the input class and the JIT class are not checked to make sure
   6 that they are the same. But classes are only started when their name is known.
   7
   8 ## 07:37
   9
  10 One thing I could do is have a field table of sorts. Basically similar to
  11 the class and resource table except that there is a linear table of field
  12 information. Then the class refers to a range in this table. The same could
  13 be done for methods. This way fields and methods do not have to be referenced
  14 by pointers. This would mean that I could allow classes to be slightly larger
  15 in size becuase I do not need pointers for all of the data. Fields do not
  16 need any pointer data at all, however methods do for code. So I could
  17 essentially keep the class a bit more compact and possibly a bit easier to
  18 parse. This also means that readers for class information can have a single
  19 `List` of fields that could have a cached representation. So this could
  20 work out very well.
  21
  22 ## 07:53
  23
  24 The same could be said for interfaces also. I would need 6 bytes for large
  25 classes, but with a single table I only need to use 4.
  26
  27 ## 08:55
  28
  29 The interface can be used also to quickly verify and actually in a way link
  30 interfaces. So basically at link time, I can scan the entire list and lookup
  31 classes to determine if they are actual interfaces. Then I would not need to
  32 check it when I load the class table. Each interface in the interface table
  33 could also have a run-time class representation binding.
  34
  35 ## 12:05
  36
  37 The extended data output streams could use exact versions of writing signed
  38 and unsigned type values, at least for `byte` and `short`.
  39
  40 ## 12:08
  41
  42 I can also have the same tables for method code too, this way code exists in
  43 a single table. When it comes to exception handling it could also be in the
  44 code table, so if a piece of code has an exception handler then it could just
  45 point to a code table index.
  46
  47 ## 18:46
  48
  49 So the question is, do I put the register allocator in the basic JIT or the
  50 native code generators. Likely the best choice would be the native code
  51 generator potentially. Although that could cause some issues if I want to
  52 generate specific instructions that are not allocated at all.
  53