mirror of
https://github.com/corda/corda.git
synced 2025-01-04 04:04:27 +00:00
252 lines
5.8 KiB
Plaintext
252 lines
5.8 KiB
Plaintext
; Copyright (c) 2008-2015, Avian Contributors
|
|
;
|
|
; 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.
|
|
;
|
|
; ORIGIN: https://github.com/gkvas/avian/tree/wince
|
|
|
|
; types.inc
|
|
VOID_TYPE equ 0
|
|
INT8_TYPE equ 1
|
|
INT16_TYPE equ 2
|
|
INT32_TYPE equ 3
|
|
INT64_TYPE equ 4
|
|
FLOAT_TYPE equ 5
|
|
DOUBLE_TYPE equ 6
|
|
POINTER_TYPE equ 7
|
|
|
|
; target-fields.inc
|
|
;TARGET_BYTES_PER_WORD = 4
|
|
|
|
TARGET_THREAD_EXCEPTION equ 44
|
|
TARGET_THREAD_EXCEPTIONSTACKADJUSTMENT equ 2164
|
|
TARGET_THREAD_EXCEPTIONOFFSET equ 2168
|
|
TARGET_THREAD_EXCEPTIONHANDLER equ 2172
|
|
|
|
TARGET_THREAD_IP equ 2144
|
|
TARGET_THREAD_STACK equ 2148
|
|
TARGET_THREAD_NEWSTACK equ 2152
|
|
TARGET_THREAD_SCRATCH equ 2156
|
|
TARGET_THREAD_CONTINUATION equ 2160
|
|
TARGET_THREAD_TAILADDRESS equ 2176
|
|
TARGET_THREAD_VIRTUALCALLTARGET equ 2180
|
|
TARGET_THREAD_VIRTUALCALLINDEX equ 2184
|
|
TARGET_THREAD_HEAPIMAGE equ 2188
|
|
TARGET_THREAD_CODEIMAGE equ 2192
|
|
TARGET_THREAD_THUNKTABLE equ 2196
|
|
TARGET_THREAD_STACKLIMIT equ 2220
|
|
|
|
AREA text, CODE, ARM
|
|
|
|
BYTES_PER_WORD equ 4
|
|
|
|
CONTINUATION_NEXT equ 4
|
|
CONTINUATION_ADDRESS equ 16
|
|
CONTINUATION_RETURN_ADDRESS_OFFSET equ 20
|
|
CONTINUATION_FRAME_POINTER_OFFSET equ 24
|
|
CONTINUATION_LENGTH equ 28
|
|
CONTINUATION_BODY equ 32
|
|
|
|
EXPORT vmInvoke
|
|
vmInvoke
|
|
|
|
; arguments
|
|
; r0 : thread
|
|
; r1 : function
|
|
; r2 : arguments
|
|
; r3 : argumentFootprint
|
|
; [sp, #0] : frameSize (not used)
|
|
; [sp, #4] : returnType
|
|
|
|
|
|
; save all non-volatile registers
|
|
stmfd sp!, {r4-r11, lr}
|
|
|
|
; save return type
|
|
ldr r4, [sp, #4]
|
|
str r4, [sp, #-4]!
|
|
|
|
str sp, [r0, #TARGET_THREAD_SCRATCH]
|
|
|
|
; align stack, if necessary
|
|
eor r4, sp, r3
|
|
tst r4, #4
|
|
subne sp, sp, #4
|
|
|
|
; copy arguments into place
|
|
sub sp, sp, r3
|
|
mov r4, #0
|
|
b vmInvoke_argumentTest
|
|
|
|
vmInvoke_argumentLoop
|
|
ldr r5, [r2, r4]
|
|
str r5, [sp, r4]
|
|
add r4, r4, #BYTES_PER_WORD
|
|
|
|
vmInvoke_argumentTest
|
|
cmp r4, r3
|
|
blt vmInvoke_argumentLoop
|
|
|
|
; we use r8 to hold the thread pointer, by convention
|
|
mov r8, r0
|
|
|
|
; load and call function address
|
|
blx r1
|
|
|
|
EXPORT vmInvoke_returnAddress
|
|
vmInvoke_returnAddress
|
|
; restore stack pointer
|
|
ldr sp, [r8, #TARGET_THREAD_SCRATCH]
|
|
|
|
; clear MyThread::stack to avoid confusing another thread calling
|
|
; java.lang.Thread.getStackTrace on this one. See
|
|
; MyProcess::getStackTrace in compile.cpp for details on how we get
|
|
; a reliable stack trace from a thread that might be interrupted at
|
|
; any point in its execution.
|
|
mov r5, #0
|
|
str r5, [r8, #TARGET_THREAD_STACK]
|
|
|
|
EXPORT vmInvoke_safeStack
|
|
vmInvoke_safeStack
|
|
|
|
;if AVIAN_CONTINUATIONS
|
|
; ; call the next continuation, if any
|
|
; ldr r5,[r8,#TARGET_THREAD_CONTINUATION]
|
|
; cmp r5,#0
|
|
; beq vmInvoke_exit)
|
|
;
|
|
; ldr r6,[r5,#CONTINUATION_LENGTH]
|
|
; lsl r6,r6,#2
|
|
; neg r7,r6
|
|
; add r7,r7,#-80
|
|
; mov r4,sp
|
|
; str r4,[sp,r7]!
|
|
;
|
|
; add r7,r5,#CONTINUATION_BODY
|
|
;
|
|
; mov r11,#0
|
|
; b vmInvoke_continuationTest
|
|
;
|
|
;vmInvoke_continuationLoop
|
|
; ldr r9,[r7,r11]
|
|
; str r9,[sp,r11]
|
|
; add r11,r11,#4
|
|
;
|
|
;vmInvoke_continuationTest
|
|
; cmp r11,r6
|
|
; ble vmInvoke_continuationLoop)
|
|
;
|
|
; ldr r7,[r5,#CONTINUATION_RETURN_ADDRESS_OFFSET]
|
|
; ldr r10,vmInvoke_returnAddress_word
|
|
; ldr r11,vmInvoke_getAddress_word
|
|
;vmInvoke_getAddress
|
|
; add r11,pc,r11
|
|
; ldr r11,[r11,r10]
|
|
; str r11,[sp,r7]
|
|
;
|
|
; ldr r7,[r5,#CONTINUATION_NEXT]
|
|
; str r7,[r8,#TARGET_THREAD_CONTINUATION]
|
|
;
|
|
; ; call the continuation unless we're handling an exception
|
|
; ldr r7,[r8,#TARGET_THREAD_EXCEPTION]
|
|
; cmp r7,#0
|
|
; bne vmInvoke_handleException)
|
|
; ldr r7,[r5,#CONTINUATION_ADDRESS]
|
|
; bx r7
|
|
;
|
|
;vmInvoke_handleException
|
|
; ; we're handling an exception - call the exception handler instead
|
|
; mov r11,#0
|
|
; str r11,[r8,#TARGET_THREAD_EXCEPTION]
|
|
; ldr r11,[r8,#TARGET_THREAD_EXCEPTIONSTACKADJUSTMENT]
|
|
; ldr r9,[sp]
|
|
; neg r11,r11
|
|
; str r9,[sp,r11]!
|
|
; ldr r11,[r8,#TARGET_THREAD_EXCEPTIONOFFSET]
|
|
; str r7,[sp,r11]
|
|
;
|
|
; ldr r7,[r8,#TARGET_THREAD_EXCEPTIONHANDLER]
|
|
; bx r7
|
|
;
|
|
;vmInvoke_exit
|
|
;endif ; AVIAN_CONTINUATIONS
|
|
|
|
mov ip, #0
|
|
str ip, [r8, #TARGET_THREAD_STACK]
|
|
|
|
; restore return type
|
|
ldr ip, [sp], #4
|
|
|
|
; restore callee-saved registers
|
|
ldmfd sp!, {r4-r11, lr}
|
|
|
|
vmInvoke_return
|
|
bx lr
|
|
|
|
EXPORT vmJumpAndInvoke
|
|
vmJumpAndInvoke
|
|
;if :DEF:AVIAN_CONTINUATIONS
|
|
; ; r0: thread
|
|
; ; r1: address
|
|
; ; r2: stack
|
|
; ; r3: argumentFootprint
|
|
; ; [sp,#0]: arguments
|
|
; ; [sp,#4]: frameSize
|
|
;
|
|
; ldr r5,[sp,#0]
|
|
; ldr r6,[sp,#4]
|
|
;
|
|
; ; allocate new frame, adding room for callee-saved registers, plus
|
|
; ; 4 bytes of padding since the calculation of frameSize assumes 4
|
|
; ; bytes have already been allocated to save the return address,
|
|
; ; which is not true in this case
|
|
; sub r2,r2,r6
|
|
; sub r2,r2,#84
|
|
;
|
|
; mov r8,r0
|
|
;
|
|
; ; copy arguments into place
|
|
; mov r6,#0
|
|
; b vmJumpAndInvoke_argumentTest
|
|
;
|
|
;vmJumpAndInvoke_argumentLoop
|
|
; ldr r12,[r5,r6]
|
|
; str r12,[r2,r6]
|
|
; add r6,r6,#4
|
|
;
|
|
;vmJumpAndInvoke_argumentTest
|
|
; cmp r6,r3
|
|
; ble vmJumpAndInvoke_argumentLoop
|
|
;
|
|
; ; the arguments have been copied, so we can set the real stack
|
|
; ; pointer now
|
|
; mov sp,r2
|
|
;
|
|
; ; set return address to vmInvoke_returnAddress
|
|
; ldr r10,vmInvoke_returnAddress_word)
|
|
; ldr r11,vmJumpAndInvoke_getAddress_word)
|
|
;vmJumpAndInvoke_getAddress
|
|
; add r11,pc,r11
|
|
; ldr lr,[r11,r10]
|
|
;
|
|
; bx r1
|
|
;
|
|
;vmInvoke_returnAddress_word
|
|
; .word GLOBAL(vmInvoke_returnAddress)(GOT)
|
|
;vmInvoke_getAddress_word
|
|
; .word _GLOBAL_OFFSET_TABLE_-(vmInvoke_getAddress)+8)
|
|
;vmJumpAndInvoke_getAddress_word
|
|
; .word _GLOBAL_OFFSET_TABLE_-(vmJumpAndInvoke_getAddress)+8)
|
|
;
|
|
;else ; not AVIAN_CONTINUATIONS
|
|
; vmJumpAndInvoke should only be called when continuations are
|
|
; enabled
|
|
bkpt 0
|
|
;endif ; not AVIAN_CONTINUATIONS
|
|
|
|
END |