DISCLAIMER: These notes are from the defunct k8 project which precedes SquirrelJME. The notes for SquirrelJME start on 2016/02/26! The k8 project was effectively a Java SE 8 operating system and as such all of the notes are in the context of that scope. That project is no longer my goal as SquirrelJME is the spiritual successor to it.


I require food, making some MSG loaded ramen noodles, very tasty.


I wonder if I can make up something shorter than FutureAndPresent.

I suppose FPUtility would work.


Also ate an older orange, but citrus should last for awhile.


It might be a bad idea to have the futures take constant values because that could hide potential errors when they are used when it is desired that they be actually not known at call time.


There is much banging under where I live, on the cold nights animals like to just cram themselves into wherever.


It would be best to make opRegisterIntAddImmediate not be final because it is possible that a machine might have it or not. If it is not overridden then a constant set and then add is used instead (slower).


I suppose I made a bunch of commits today by doing a refactor of the assembler and some of the generation code. Although I made no progress writing class data for the most part. However, the new assembler and future stuff will be handy in the future, pun intended.


Right now I have a block on a TODO, but the following assembly code was generated:


Which disassembles to:

   0:   3f 60 00 00     lis     r27,0
   4:   63 7b 00 58     ori     r27,r27,88
   8:   93 61 00 1c     stw     r27,28(r1)
   c:   7c 20 04 ac     lwsync
  10:   80 c2 00 04     lwz     r6,4(r2)
  14:   90 c1 ff b4     stw     r6,-76(r1)
  18:   90 c1 ff c4     stw     r6,-60(r1)
  1c:   90 21 ff a4     stw     r1,-92(r1)
  20:   90 41 ff a0     stw     r2,-96(r1)
  24:   90 41 ff ec     stw     r2,-20(r1)
  28:   7f 88 02 a6     mflr    r28
  2c:   93 81 ff e8     stw     r28,-24(r1)
  30:   80 61 ff c4     lwz     r3,-60(r1)
  34:   7c 20 04 ac     lwsync
  38:   83 62 00 00     lwz     r27,0(r2)
  3c:   7c 20 04 ac     lwsync
  40:   80 42 00 08     lwz     r2,8(r2)
  44:   3f 80 00 00     lis     r28,0
  48:   63 9c 00 58     ori     r28,r28,88
  4c:   7c 21 e2 14     add     r1,r1,r28
  50:   7f 68 03 a6     mtlr    r27
  54:   4e 80 00 21     blrl
  58:   80 21 ff fc     lwz     r1,-4(r1)
  5c:   80 41 ff ec     lwz     r2,-20(r1)
  60:   83 81 ff e8     lwz     r28,-24(r1)
  64:   7f 88 03 a6     mtlr    r28
  68:   7c 63 1b 78     mr      r3,r3
  6c:   80 c1 ff c4     lwz     r6,-60(r1)
  70:   90 61 ff b0     stw     r3,-80(r1)
  74:   7c 66 1b 78     mr      r6,r3
  78:   7c 64 1b 78     mr      r4,r3
  7c:   7c c3 33 78     mr      r3,r6
  80:   7c 20 04 ac     lwsync
  84:   80 a2 00 0c     lwz     r5,12(r2)
  88:   90 a1 ff ac     stw     r5,-84(r1)
  8c:   2c 04 00 00     cmpwi   r4,0
  90:   40 82 00 64     bne     f4 <_binary__tmp_25162_start+0xf4>
  94:   90 61 ff d0     stw     r3,-48(r1)
  98:   90 81 ff cc     stw     r4,-52(r1)
  9c:   90 a1 ff c8     stw     r5,-56(r1)
  a0:   90 21 ff a4     stw     r1,-92(r1)
  a4:   90 41 ff a0     stw     r2,-96(r1)
  a8:   90 41 ff ec     stw     r2,-20(r1)
  ac:   7f 88 02 a6     mflr    r28
  b0:   93 81 ff e8     stw     r28,-24(r1)
  b4:   7c 20 04 ac     lwsync
  b8:   83 62 00 14     lwz     r27,20(r2)
  bc:   7c 20 04 ac     lwsync
  c0:   80 42 00 18     lwz     r2,24(r2)
  c4:   3f 80 00 00     lis     r28,0
  c8:   63 9c 00 58     ori     r28,r28,88
  cc:   7c 21 e2 14     add     r1,r1,r28
  d0:   7f 68 03 a6     mtlr    r27
  d4:   4e 80 00 21     blrl
  d8:   80 21 ff fc     lwz     r1,-4(r1)
  dc:   80 41 ff ec     lwz     r2,-20(r1)
  e0:   83 81 ff e8     lwz     r28,-24(r1)
  e4:   7f 88 03 a6     mtlr    r28
  e8:   80 61 ff d0     lwz     r3,-48(r1)
  ec:   80 81 ff cc     lwz     r4,-52(r1)
  f0:   80 a1 ff c8     lwz     r5,-56(r1)
  f4:   90 61 ff d0     stw     r3,-48(r1)
  f8:   90 81 ff cc     stw     r4,-52(r1)
  fc:   90 a1 ff c8     stw     r5,-56(r1)
 100:   90 21 ff a4     stw     r1,-92(r1)
 104:   90 41 ff a0     stw     r2,-96(r1)
 108:   90 41 ff ec     stw     r2,-20(r1)
 10c:   7f 88 02 a6     mflr    r28
 110:   93 81 ff e8     stw     r28,-24(r1)
 114:   80 61 ff cc     lwz     r3,-52(r1)
 118:   80 81 ff c8     lwz     r4,-56(r1)
 11c:   7c 20 04 ac     lwsync
 120:   83 62 00 10     lwz     r27,16(r2)
 124:   7c 20 04 ac     lwsync
 128:   80 42 00 1c     lwz     r2,28(r2)
 12c:   3f 80 00 00     lis     r28,0
 130:   63 9c 00 58     ori     r28,r28,88
 134:   7c 21 e2 14     add     r1,r1,r28
 138:   7f 68 03 a6     mtlr    r27
 13c:   4e 80 00 21     blrl
 140:   80 21 ff fc     lwz     r1,-4(r1)
 144:   80 41 ff ec     lwz     r2,-20(r1)
 148:   83 81 ff e8     lwz     r28,-24(r1)
 14c:   7f 88 03 a6     mtlr    r28
 150:   80 61 ff d0     lwz     r3,-48(r1)
 154:   80 81 ff cc     lwz     r4,-52(r1)
 158:   80 a1 ff c8     lwz     r5,-56(r1)
 15c:   90 61 ff d0     stw     r3,-48(r1)
 160:   90 21 ff a4     stw     r1,-92(r1)
 164:   90 41 ff a0     stw     r2,-96(r1)
 168:   90 41 ff ec     stw     r2,-20(r1)
 16c:   7f 88 02 a6     mflr    r28
 170:   93 81 ff e8     stw     r28,-24(r1)
 174:   80 61 ff d0     lwz     r3,-48(r1)
 178:   7c 20 04 ac     lwsync
 17c:   83 62 00 20     lwz     r27,32(r2)
 180:   7c 20 04 ac     lwsync
 184:   80 42 00 24     lwz     r2,36(r2)
 188:   3f 80 00 00     lis     r28,0
 18c:   63 9c 00 58     ori     r28,r28,88
 190:   7c 21 e2 14     add     r1,r1,r28
 194:   7f 68 03 a6     mtlr    r27
 198:   4e 80 00 21     blrl
 19c:   80 21 ff fc     lwz     r1,-4(r1)
 1a0:   80 41 ff ec     lwz     r2,-20(r1)
 1a4:   83 81 ff e8     lwz     r28,-24(r1)
 1a8:   7f 88 03 a6     mtlr    r28
 1ac:   80 61 ff d0     lwz     r3,-48(r1)

And the other being:


Not going to bother with running this through objdump.

Looking at the disassembly one will find pointless operations. Since POIT is a literal translation of the Java byte code, this is essentially how it looks as if it were byte code. Obviously when I get to NARF there will be lots of room for improvement.


I suppose I should continue outputting class information now that the assembler stuff has been refactored a bit. There was also the hairball refactor. The added Device I/O should be very useful in the future.


I believe for a bootstrap VM I will take a hybrid approach. Since I want to support ancient Java versions and cripply devices such as J2ME phones to build and compile k8 with, I can recompile part of my class library with a potential extension stub. So basically, the bootstrap VM will be written in Java 8 naturally, however it will rely on the recompiler (POIT) to translate some of the code to a lower Java version. Then support for specific subsystems whether it be Java SE or J2ME will be in an extra package with the required implemented interfaces and such.


I suppose the helper code would be what is needed for the VM to run so it would be very minimal and hopefully not require class loader or reflection magic. One thing though is translating lambdas to an older Java version. J2ME devices for example lack ClassLoader so they have only static classes available. A bunch of my Java 8 code uses lambdas, so I would have to figure out a solution for it. I suppose what I can do is have a kind of lambda or reflection farm which knows how to call every single method in a static form. So essentially I could fake reflection with static classes by using static proxies.


Actually that is incorrect. J2ME does have reflection however there is only a single call and that is being Class.forName(String). So this simplifies things a bit. There is also luckily newInstance() too. So although very limited doing such a bootstrap would be much easier. I had code previously also which I wrote when I did not know about these two important methods. I must have glossed over them when looking around the limited class library.


J2ME does not support adding parameters to constructors, so basically if I want constructor alikes I will need to then make factory classes which contain methods for construction.

So in short, these two methods completely change things and make things easier. This means I will not have to create a hybrid-like emulator so to speak. However I will have to figure out about exceptions and such and control flow in Java programs.


For C compatibility I suppose I should just merge the entire set and instead have a POSIX compatibility package which contains everything POSIX.


I should probably codename the POSIX environment instead so I can provide non-POSIX stuff also. I will have to do that for stuff such as the java command for example. Suppose I will take a break from the KBF writing and write this POSIX stuff for a bit.


One thing though is, I cannot support fork at all so that leaves only posix_pspawn. Supporting fork in Java would probably be a huge undertaking and would be rather difficult in Java. Actually it is called posix_spawnp.


For multi-process there will need to be some kind of lock shared between processes. As such, instead of using synchronized the only choice is to use standard locks. However with try/finally it will not be a horrible mess at all.


Output Java code actually could work with a loop where each operation changes the next execution pointer. So basically it would look something such as:

while (addr >= 0)
	switch (addr)
		case 0:
			addr = __add(a, b);

		case 2:
			addr = __return(a);

And that would essentially be the whole thing. Would be slow though but it would work without worrying about how special jumps and such are handled.


The only problem when it comes to the code is signals and throwing exceptions in the middle of code. However, most normal commands will not handle signals at all. However they will have to handle stuff such as SIGKILL so that they stop execution.


Hopefully I can coding the POSIX stuff in a way where when it is to be used in my operating system as a native non-simulated thing it does not cause chaos to happen. Thinking about it, the kernel could run the code in a loop and that would be the userspace for the most part.


Yknow, I could name my OS Foobarniux. It is an odd name however.

However, I can use the process and thread stuff and then just generalize it so to speak so that what I am writing is part of the kernel so to speak.

As for the name k8 is still shorter though but probably not as unique.

So what I should probably do then is split some of the POSIXProcess and POSIXThread stuff into a kernel specific control setup of sorts. Then this way iot can be reused by the kernel itself without writing anything twice.


Looking online it does not appear the name has been taken at all.

However most of my documentation for the most part and all my sources use "k8" everywhere. So some stuff would be out of date while others would not be.




It might be easier for the bootstrap to be Foobarniux to be a basic MIPS system so to speak. So basically if the Java version is say 1.2 then the bootstrap system will be built which is essentially a MIPS emulator which then runs the kernel and anything else using the host filesystem for the most part. This might be the simplest thing to do when it comes to the bootstrap environment. However this gets complex. I am divided on this. The bootstrap stuff can be in ugly old Java code and it would work then for the most part except for some gotchas.

So I suppose having a MIPS emulation system would complicate things so to speak as it would require a double bootstrap or keeping binaries in the source. So I will go with ugly Java loop code to handle it all. Then that way if the VM has a JIT or similar it can just run it at a slightly faster speed despite the code probably being the worst when it comes to optimization and speed as it would be layered right on top of POIT.


As for the POSIX/UNIX stuff I can instead have a base package which provides basic utility support so to speak.


I do wonder though if POSIX stuff can go fine without raise() and signals because Java does not really have such things.


For the POSIX stuff I can make it easier and use ThreadLocal. When I need to do something such as in a compiled C program.


I had a strong cup of coffee possibly, quite nasty. I need to reset my sleep so that I wake up at 5:00 instead of 12:00 and then sleep when it gets near dark. So hopefully I make it through the night. I feel all shaky eyed though currently and everything seems a bit green. I have not drank coffee in awhile though. So yeah my vision feels like when you just stare and everything just starts to fade away. I suppose I am starting to feel the effects of the caffeine. So I suppose I could use some motivation music and then get to work by not feature creeping with the POSIX code. I am just going to set a note that it is going to go away in the future with new stuff once I get further.


The clock nears a new day. The song I am currently listening to is called Path To Nowhere. I believe this is the last tracker module this person made, however it is a really nice song. Trackers are awesome.