ExternalVendorCode/corda
1
0
Fork 0
mirror of https://github.com/corda/corda.git synced 2025-01-08 14:03:06 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
b9e281612b
corda/src/arm.S

133 lines
2.6 KiB
ArmAsm
Raw Normal View History

clean up binary format code Linux, FreeBSD, and QNX all use ELF, so no need to distinguish between them when generating object files. To avoid confusion, I've switch from using operating system names to using binary format names where applicable.
2012-08-02 18:15:15 +00:00
/* arm.S: JNI gluecode for ARM
update copyright years and increment version number
2011-07-13 14:25:21 +00:00
Copyright (c) 2008-2011, Avian Contributors
added ARM interpreted mode supported
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. */
add support for the ARM hardware floating point ABI This ABI's calling convention passes arguments and returns results using VFP registers, so we need to tweak vmNativeCall to match it. Thanks to Damjan Jovanovic for pointing this out and providing an initial patch.
2012-07-31 16:36:01 +00:00
#include "types.h"
added ARM interpreted mode supported
2009-08-06 17:52:36 +00:00
.text
add support for Apple iOS on ARM Most tests are passing, but not all, so this still needs more work.
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)
specify 4-byte alignment of functions defined in ARM assembly code Apple's assembler, at least, won't automatically align these properly for us, so we need to explicitly specify the required alignment.
2012-01-19 23:40:50 +00:00
.align 2
add support for Apple iOS on ARM Most tests are passing, but not all, so this still needs more work.
2011-08-11 01:21:48 +00:00
GLOBAL(vmNativeCall):
added ARM interpreted mode supported
2009-08-06 17:52:36 +00:00
/*
arguments:
r0 -> r4 : function
r1 -> r5 : stackTotal
r2 : memoryTable
r3 : memoryCount
[sp, #0] -> r6 : gprTable
add support for the ARM hardware floating point ABI This ABI's calling convention passes arguments and returns results using VFP registers, so we need to tweak vmNativeCall to match it. Thanks to Damjan Jovanovic for pointing this out and providing an initial patch.
2012-07-31 16:36:01 +00:00
[sp, #4] -> r7 : vfpTable
[sp, #8] -> r8 : returnType
added ARM interpreted mode supported
2009-08-06 17:52:36 +00:00
*/
mov ip, sp // save stack frame
add support for the ARM hardware floating point ABI This ABI's calling convention passes arguments and returns results using VFP registers, so we need to tweak vmNativeCall to match it. Thanks to Damjan Jovanovic for pointing this out and providing an initial patch.
2012-07-31 16:36:01 +00:00
stmfd sp!, {r4-r8, lr} // save clobbered non-volatile regs
added ARM interpreted mode supported
2009-08-06 17:52:36 +00:00
// mv args into non-volatile regs
mov r4, r0
mov r5, r1
ldr r6, [ip]
add support for the ARM hardware floating point ABI This ABI's calling convention passes arguments and returns results using VFP registers, so we need to tweak vmNativeCall to match it. Thanks to Damjan Jovanovic for pointing this out and providing an initial patch.
2012-07-31 16:36:01 +00:00
ldr r7, [ip, #4]
ldr r8, [ip, #8]
added ARM interpreted mode supported
2009-08-06 17:52:36 +00:00
// setup stack arguments if necessary
sub sp, sp, r5 // allocate stack
mov ip, sp
add support for Apple iOS on ARM Most tests are passing, but not all, so this still needs more work.
2011-08-11 01:21:48 +00:00
LOCAL(loop):
added ARM interpreted mode supported
2009-08-06 17:52:36 +00:00
tst r3, r3
ldrne r0, [r2], #4
strne r0, [ip], #4
subne r3, r3, #4
add support for Apple iOS on ARM Most tests are passing, but not all, so this still needs more work.
2011-08-11 01:21:48 +00:00
bne LOCAL(loop)
added ARM interpreted mode supported
2009-08-06 17:52:36 +00:00
// setup argument registers if necessary
tst r6, r6
use ldmneia on Clang < 4 and GCC, ldmiane on Clang >= 4 I don't know why this instruction was renamed, but we have to deal with it.
2012-10-03 23:01:00 +00:00
#if (defined __APPLE__) && (defined __clang_major__) && (__clang_major__ >= 4)
fix OS X 10.8 and iOS 6.0 builds This also adds support for Clang ARM builds, which involved removing unused functions from arm.cpp to avoid link-time warnings.
2012-10-03 19:36:51 +00:00
ldmiane r6, {r0-r3}
#else
added ARM interpreted mode supported
2009-08-06 17:52:36 +00:00
ldmneia r6, {r0-r3}
fix OS X 10.8 and iOS 6.0 builds This also adds support for Clang ARM builds, which involved removing unused functions from arm.cpp to avoid link-time warnings.
2012-10-03 19:36:51 +00:00
#endif
gcc define __ARM_PCS_VFP for -mfloat-abi=hard, use it to detect armhf builds. Signed-off-by: Xerxes Rånby <xerxes@zafena.se>
2012-10-01 11:39:18 +00:00
#if defined(__ARM_PCS_VFP)
add support for the ARM hardware floating point ABI This ABI's calling convention passes arguments and returns results using VFP registers, so we need to tweak vmNativeCall to match it. Thanks to Damjan Jovanovic for pointing this out and providing an initial patch.
2012-07-31 16:36:01 +00:00
// and VFP registers
load arguments into the first 8 VFP registers, not the first 9
2012-08-01 19:59:34 +00:00
vldmia r7, {d0-d7}
add support for the ARM hardware floating point ABI This ABI's calling convention passes arguments and returns results using VFP registers, so we need to tweak vmNativeCall to match it. Thanks to Damjan Jovanovic for pointing this out and providing an initial patch.
2012-07-31 16:36:01 +00:00
#endif
added ARM interpreted mode supported
2009-08-06 17:52:36 +00:00
Fix missing armv4 blx and bkpt compile errors. Signed-off-by: Xerxes Rånby <xerxes@zafena.se>
2012-09-25 13:54:32 +00:00
#if defined(__ARM_ARCH_4__) || defined(__ARM_ARCH_4T__)
mov lr, pc
bx r4
#else
added ARM interpreted mode supported
2009-08-06 17:52:36 +00:00
blx r4 // call function
Fix missing armv4 blx and bkpt compile errors. Signed-off-by: Xerxes Rånby <xerxes@zafena.se>
2012-09-25 13:54:32 +00:00
#endif
added ARM interpreted mode supported
2009-08-06 17:52:36 +00:00
add sp, sp, r5 // deallocate stack
gcc define __ARM_PCS_VFP for -mfloat-abi=hard, use it to detect armhf builds. Signed-off-by: Xerxes Rånby <xerxes@zafena.se>
2012-10-01 11:39:18 +00:00
#if defined(__ARM_PCS_VFP)
add support for the ARM hardware floating point ABI This ABI's calling convention passes arguments and returns results using VFP registers, so we need to tweak vmNativeCall to match it. Thanks to Damjan Jovanovic for pointing this out and providing an initial patch.
2012-07-31 16:36:01 +00:00
cmp r8,#FLOAT_TYPE
bne LOCAL(double)
fmrs r0,s0
b LOCAL(exit)
LOCAL(double):
cmp r8,#DOUBLE_TYPE
bne LOCAL(exit)
fmrrd r0,r1,d0
#endif
LOCAL(exit):
ldmfd sp!, {r4-r8, pc} // restore non-volatile regs and return
added ARM interpreted mode supported
2009-08-06 17:52:36 +00:00
add support for Apple iOS on ARM Most tests are passing, but not all, so this still needs more work.
2011-08-11 01:21:48 +00:00
.globl GLOBAL(vmJump)
specify 4-byte alignment of functions defined in ARM assembly code Apple's assembler, at least, won't automatically align these properly for us, so we need to explicitly specify the required alignment.
2012-01-19 23:40:50 +00:00
.align 2
add support for Apple iOS on ARM Most tests are passing, but not all, so this still needs more work.
2011-08-11 01:21:48 +00:00
GLOBAL(vmJump):
Further debugging of ARM "Hello World!" JIT functionality.
2010-08-28 00:52:33 +00:00
mov lr, r0
ldr r0, [sp]
ldr r1, [sp, #4]
added ARM interpreted mode supported
2009-08-06 17:52:36 +00:00
mov sp, r2
Further debugging of ARM "Hello World!" JIT functionality.
2010-08-28 00:52:33 +00:00
mov r8, r3
First version; interpreted mode works and JIT mode compiles.
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
add support for Apple iOS on ARM Most tests are passing, but not all, so this still needs more work.
2011-08-11 01:21:48 +00:00
.globl GLOBAL(vmRun)
specify 4-byte alignment of functions defined in ARM assembly code Apple's assembler, at least, won't automatically align these properly for us, so we need to explicitly specify the required alignment.
2012-01-19 23:40:50 +00:00
.align 2
add support for Apple iOS on ARM Most tests are passing, but not all, so this still needs more work.
2011-08-11 01:21:48 +00:00
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}
preserve statck alignment in arm.S's vmRun
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]
Fix missing armv4 blx and bkpt compile errors. Signed-off-by: Xerxes Rånby <xerxes@zafena.se>
2012-09-25 13:54:32 +00:00
#if defined(__ARM_ARCH_4__) || defined(__ARM_ARCH_4T__)
mov lr, pc
bx r12
#else
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
blx r12
Fix missing armv4 blx and bkpt compile errors. Signed-off-by: Xerxes Rånby <xerxes@zafena.se>
2012-09-25 13:54:32 +00:00
#endif
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
add support for Apple iOS on ARM Most tests are passing, but not all, so this still needs more work.
2011-08-11 01:21:48 +00:00
.globl GLOBAL(vmRun_returnAddress)
specify 4-byte alignment of functions defined in ARM assembly code Apple's assembler, at least, won't automatically align these properly for us, so we need to explicitly specify the required alignment.
2012-01-19 23:40:50 +00:00
.align 2
add support for Apple iOS on ARM Most tests are passing, but not all, so this still needs more work.
2011-08-11 01:21:48 +00:00
GLOBAL(vmRun_returnAddress):
preserve statck alignment in arm.S's vmRun
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
Reference in New Issue Copy Permalink