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

   1 # 2016/09/23
   2
   3 ## 07:49
   4
   5 Actually, I believe the register setup which I have planned would be a bit
   6 complex, when it comes to the stack. Perhaps what I need are value write
   7 sizes. Essentially these specify the number of bytes that are permitted to
   8 be written into memory. Basically for MIPS and PowerPC these would be 1, 2,
   9 4, and 8 (for PowerPC or 64-bit). This could be used by the allocation code
  10 to potentially determine the best way to allocate values. I suppose there
  11 can also be another flag for something called unaligned access. If that is
  12 true then alignment does not matter, however if it does then it will be
  13 based on the write size.
  14
  15 ## 08:03
  16
  17 Actually, most of the complexities that I am currently running into are that
  18 allocations do not have to be pure. Basically, values are stored across
  19 registers and stack positions, but not both. It would be far simpler if
  20 values were allocated purely in registers. For values of a given type on
  21 system with lower register storages, if they cannot purely fit then they
  22 can go onto the stack. This way handling of allocations would be far easier
  23 and less complicated. This means however that on 8-bit systems with few
  24 registers that most values would be stored on the stack. So I propose for
  25 simplicity that allocations done by the basic code generator and such are
  26 pure.
  27
  28 ## 09:08
  29
  30 So what I need are based methods for memory copy operations, basically
  31 load and stores into allocations.
  32
  33 ## 09:17
  34
  35 Thinking about it, the `NativeAllocation` can be semi-hacked with when
  36 writing load/store. Essentially say one wants to store a byte into a given
  37 array, what can be done is essentially to create a new `NativeAllocation`
  38 with that given register but with a smaller value type such as byte.
  39
  40 ## 10:02
  41
  42 Determining the best way to write this code. However, when it comes to the
  43 value copying the offsets for the source and the base are the same, they
  44 just have differing bases.
  45
  46 ## 16:07
  47
  48 It would be best if the native code writer has a lower level register
  49 load/store so that operating on allocations is not required. One example of
  50 the register load/store would potentially be by other operations.