Lately I’ve been experimenting with the idea of a generic Linux port of Hotspot. I updated the templater and generated a new set of stubs, fixed the build system to build them, then started filling them in. I got into interpreter code in a couple of days, which is where the fun starts. There’s two big problems: handling the stack, and calling native functions. libffi can do the latter, but the stack is looking to be fun. I was trying not to start thinking about it before Christmas but I failed…
My original idea was not to use the runtime stack at all: just allocate a block of memory somewhere and use that as the Java stack. Great. Ok, you need to make the garbage collector know about it, but great. Except that it turns out that synchronization works by exchanging the pointer to a locked object with a pointer to the lock, and the way it distinguishes the two is that the locks live in the runtime stack. I tried to figure a way of allocating my big block on the stack at the start of the thread, which it turns out is totally possible for created threads but totally not possible for attached threads.
Now I’m thinking about using
alloca() to sneak the Java frames inside the runtime frames. My idea was that if
alloca() allocates memory contiguously then so long as nothing else in your method used it you could “resize” your Java frame by simply allocating another block. You couldn’t resize your caller’s frame, but you can work around that with a copy. However, the code that GCC generates is weird, and I’m hoping it’s simply a bug. On i386 you get this:
mov bytes_to_allocate,%eax add $0xf,%eax add $0xf,%eax shr $0x4,%eax shl $0x4,%eax sub %eax,%esp
and on ppc you get this:
lwz r9,bytes_to_allocate addi r9,r9,15 addi r0,r9,15 rlwinm r0,r0,28,4,31 rlwinm r0,r0,4,0,27 lwz r9,0(r1) neg r0,r0 stwux r9,r1,r0 lwz r11,0(r1) lwz r0,4(r11) mtlr r0
It looks like it’s trying to align the blocks on 16-byte boundaries and that that second addition is a bug. But where to find a GCC guru at this time of year?