2009-08-06 17:52:36 +00:00
|
|
|
/* arm.S: JNI gluecode for ARM/Linux
|
2011-07-13 14:25:21 +00:00
|
|
|
Copyright (c) 2008-2011, Avian Contributors
|
2009-08-06 17:52:36 +00:00
|
|
|
|
|
|
|
|
Permission to use, copy, modify, and/or distribute this software
|
|
|
|
|
for any purpose with or without fee is hereby granted, provided
|
|
|
|
|
that the above copyright notice and this permission notice appear
|
|
|
|
|
in all copies.
|
|
|
|
|
|
|
|
|
|
There is NO WARRANTY for this software. See license.txt for
|
|
|
|
|
details. */
|
|
|
|
|
|
|
|
|
|
.text
|
|
|
|
|
|
2011-08-11 01:21:48 +00:00
|
|
|
#define LOCAL(x) .L##x
|
|
|
|
|
|
|
|
|
|
#ifdef __APPLE__
|
|
|
|
|
# define GLOBAL(x) _##x
|
|
|
|
|
#else
|
|
|
|
|
# define GLOBAL(x) x
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
.globl GLOBAL(vmNativeCall)
|
|
|
|
|
GLOBAL(vmNativeCall):
|
2009-08-06 17:52:36 +00:00
|
|
|
/*
|
|
|
|
|
arguments:
|
|
|
|
|
r0 -> r4 : function
|
|
|
|
|
r1 -> r5 : stackTotal
|
|
|
|
|
r2 : memoryTable
|
|
|
|
|
r3 : memoryCount
|
|
|
|
|
[sp, #0] -> r6 : gprTable
|
|
|
|
|
*/
|
|
|
|
|
mov ip, sp // save stack frame
|
|
|
|
|
stmfd sp!, {r4-r6, lr} // save clobbered non-volatile regs
|
|
|
|
|
|
|
|
|
|
// mv args into non-volatile regs
|
|
|
|
|
mov r4, r0
|
|
|
|
|
mov r5, r1
|
|
|
|
|
ldr r6, [ip]
|
|
|
|
|
|
|
|
|
|
// setup stack arguments if necessary
|
|
|
|
|
sub sp, sp, r5 // allocate stack
|
|
|
|
|
mov ip, sp
|
2011-08-11 01:21:48 +00:00
|
|
|
LOCAL(loop):
|
2009-08-06 17:52:36 +00:00
|
|
|
tst r3, r3
|
|
|
|
|
ldrne r0, [r2], #4
|
|
|
|
|
strne r0, [ip], #4
|
|
|
|
|
subne r3, r3, #4
|
2011-08-11 01:21:48 +00:00
|
|
|
bne LOCAL(loop)
|
2009-08-06 17:52:36 +00:00
|
|
|
|
|
|
|
|
// setup argument registers if necessary
|
|
|
|
|
tst r6, r6
|
|
|
|
|
ldmneia r6, {r0-r3}
|
|
|
|
|
|
|
|
|
|
blx r4 // call function
|
|
|
|
|
add sp, sp, r5 // deallocate stack
|
|
|
|
|
|
|
|
|
|
ldmfd sp!, {r4-r6, pc} // restore non-volatile regs and return
|
|
|
|
|
|
2011-08-11 01:21:48 +00:00
|
|
|
.globl GLOBAL(vmJump)
|
|
|
|
|
GLOBAL(vmJump):
|
2010-08-28 00:52:33 +00:00
|
|
|
mov lr, r0
|
|
|
|
|
ldr r0, [sp]
|
|
|
|
|
ldr r1, [sp, #4]
|
2009-08-06 17:52:36 +00:00
|
|
|
mov sp, r2
|
2010-08-28 00:52:33 +00:00
|
|
|
mov r8, r3
|
2010-07-12 20:18:36 +00:00
|
|
|
bx lr
|
support stack unwinding without using a frame pointer
Previously, we unwound the stack by following the chain of frame
pointers for normal returns, stack trace creation, and exception
unwinding. On x86, this required reserving EBP/RBP for frame pointer
duties, making it unavailable for general computation and requiring
that it be explicitly saved and restored on entry and exit,
respectively.
On PowerPC, we use an ABI that makes the stack pointer double as a
frame pointer, so it doesn't cost us anything. We've been using the
same convention on ARM, but it doesn't match the native calling
convention, which makes it unusable when we want to call native code
from Java and pass arguments on the stack.
So far, the ARM calling convention mismatch hasn't been an issue
because we've never passed more arguments from Java to native code
than would fit in registers. However, we must now pass an extra
argument (the thread pointer) to e.g. divideLong so it can throw an
exception on divide by zero, which means the last argument must be
passed on the stack. This will clobber the linkage area we've been
using to hold the frame pointer, so we need to stop using it.
One solution would be to use the same convention on ARM as we do on
x86, but this would introduce the same overhead of making a register
unavailable for general use and extra code at method entry and exit.
Instead, this commit removes the need for a frame pointer. Unwinding
involves consulting a map of instruction offsets to frame sizes which
is generated at compile time. This is necessary because stack trace
creation can happen at any time due to Thread.getStackTrace being
called by another thread, and the frame size varies during the
execution of a method.
So far, only x86(_64) is working, and continuations and tail call
optimization are probably broken. More to come.
2011-01-17 02:05:05 +00:00
|
|
|
|
|
|
|
|
#define CHECKPOINT_THREAD 4
|
|
|
|
|
#define CHECKPOINT_STACK 24
|
|
|
|
|
|
2011-08-11 01:21:48 +00:00
|
|
|
.globl GLOBAL(vmRun)
|
|
|
|
|
GLOBAL(vmRun):
|
support stack unwinding without using a frame pointer
Previously, we unwound the stack by following the chain of frame
pointers for normal returns, stack trace creation, and exception
unwinding. On x86, this required reserving EBP/RBP for frame pointer
duties, making it unavailable for general computation and requiring
that it be explicitly saved and restored on entry and exit,
respectively.
On PowerPC, we use an ABI that makes the stack pointer double as a
frame pointer, so it doesn't cost us anything. We've been using the
same convention on ARM, but it doesn't match the native calling
convention, which makes it unusable when we want to call native code
from Java and pass arguments on the stack.
So far, the ARM calling convention mismatch hasn't been an issue
because we've never passed more arguments from Java to native code
than would fit in registers. However, we must now pass an extra
argument (the thread pointer) to e.g. divideLong so it can throw an
exception on divide by zero, which means the last argument must be
passed on the stack. This will clobber the linkage area we've been
using to hold the frame pointer, so we need to stop using it.
One solution would be to use the same convention on ARM as we do on
x86, but this would introduce the same overhead of making a register
unavailable for general use and extra code at method entry and exit.
Instead, this commit removes the need for a frame pointer. Unwinding
involves consulting a map of instruction offsets to frame sizes which
is generated at compile time. This is necessary because stack trace
creation can happen at any time due to Thread.getStackTrace being
called by another thread, and the frame size varies during the
execution of a method.
So far, only x86(_64) is working, and continuations and tail call
optimization are probably broken. More to come.
2011-01-17 02:05:05 +00:00
|
|
|
// r0: function
|
|
|
|
|
// r1: arguments
|
|
|
|
|
// r2: checkpoint
|
|
|
|
|
stmfd sp!, {r4-r11, lr}
|
2011-02-20 02:48:56 +00:00
|
|
|
// align stack
|
|
|
|
|
sub sp, sp, #12
|
support stack unwinding without using a frame pointer
Previously, we unwound the stack by following the chain of frame
pointers for normal returns, stack trace creation, and exception
unwinding. On x86, this required reserving EBP/RBP for frame pointer
duties, making it unavailable for general computation and requiring
that it be explicitly saved and restored on entry and exit,
respectively.
On PowerPC, we use an ABI that makes the stack pointer double as a
frame pointer, so it doesn't cost us anything. We've been using the
same convention on ARM, but it doesn't match the native calling
convention, which makes it unusable when we want to call native code
from Java and pass arguments on the stack.
So far, the ARM calling convention mismatch hasn't been an issue
because we've never passed more arguments from Java to native code
than would fit in registers. However, we must now pass an extra
argument (the thread pointer) to e.g. divideLong so it can throw an
exception on divide by zero, which means the last argument must be
passed on the stack. This will clobber the linkage area we've been
using to hold the frame pointer, so we need to stop using it.
One solution would be to use the same convention on ARM as we do on
x86, but this would introduce the same overhead of making a register
unavailable for general use and extra code at method entry and exit.
Instead, this commit removes the need for a frame pointer. Unwinding
involves consulting a map of instruction offsets to frame sizes which
is generated at compile time. This is necessary because stack trace
creation can happen at any time due to Thread.getStackTrace being
called by another thread, and the frame size varies during the
execution of a method.
So far, only x86(_64) is working, and continuations and tail call
optimization are probably broken. More to come.
2011-01-17 02:05:05 +00:00
|
|
|
|
|
|
|
|
str sp, [r2, #CHECKPOINT_STACK]
|
|
|
|
|
|
|
|
|
|
mov r12, r0
|
|
|
|
|
ldr r0, [r2, #CHECKPOINT_THREAD]
|
|
|
|
|
|
|
|
|
|
blx r12
|
|
|
|
|
|
2011-08-11 01:21:48 +00:00
|
|
|
.globl GLOBAL(vmRun_returnAddress)
|
|
|
|
|
GLOBAL(vmRun_returnAddress):
|
2011-02-20 02:48:56 +00:00
|
|
|
add sp, sp, #12
|
support stack unwinding without using a frame pointer
Previously, we unwound the stack by following the chain of frame
pointers for normal returns, stack trace creation, and exception
unwinding. On x86, this required reserving EBP/RBP for frame pointer
duties, making it unavailable for general computation and requiring
that it be explicitly saved and restored on entry and exit,
respectively.
On PowerPC, we use an ABI that makes the stack pointer double as a
frame pointer, so it doesn't cost us anything. We've been using the
same convention on ARM, but it doesn't match the native calling
convention, which makes it unusable when we want to call native code
from Java and pass arguments on the stack.
So far, the ARM calling convention mismatch hasn't been an issue
because we've never passed more arguments from Java to native code
than would fit in registers. However, we must now pass an extra
argument (the thread pointer) to e.g. divideLong so it can throw an
exception on divide by zero, which means the last argument must be
passed on the stack. This will clobber the linkage area we've been
using to hold the frame pointer, so we need to stop using it.
One solution would be to use the same convention on ARM as we do on
x86, but this would introduce the same overhead of making a register
unavailable for general use and extra code at method entry and exit.
Instead, this commit removes the need for a frame pointer. Unwinding
involves consulting a map of instruction offsets to frame sizes which
is generated at compile time. This is necessary because stack trace
creation can happen at any time due to Thread.getStackTrace being
called by another thread, and the frame size varies during the
execution of a method.
So far, only x86(_64) is working, and continuations and tail call
optimization are probably broken. More to come.
2011-01-17 02:05:05 +00:00
|
|
|
ldmfd sp!, {r4-r11, lr}
|
|
|
|
|
bx lr
|
