178 lines
2.8 KiB
ArmAsm
178 lines
2.8 KiB
ArmAsm
.global callvm_invoke_i
|
|
.type callvm_invoke_i, @function
|
|
|
|
# %rdi = (function ptr) impl
|
|
# %rsi = (struct callvm) context
|
|
callvm_invoke_i:
|
|
# save the stack frame pointer
|
|
push %rbp
|
|
mov %rsp, %rbp
|
|
|
|
# store function pointer for later
|
|
push %r12
|
|
push %r13
|
|
push %r14
|
|
push %r15
|
|
|
|
mov %rdi, %r11
|
|
mov %rsi, %r12
|
|
|
|
# First, set up the fixed arguments
|
|
# %r13 = fixed arg count
|
|
movq (%r12), %r13
|
|
|
|
# arg[0]
|
|
cmp $0, %r13
|
|
jle .idone
|
|
movq 48(%r12), %rdi
|
|
|
|
# arg[1]
|
|
cmp $1, %r13
|
|
jle .idone
|
|
movq 56(%r12), %rsi
|
|
|
|
# arg[2]
|
|
cmp $2, %r13
|
|
jle .idone
|
|
movq 64(%r12), %rdx
|
|
|
|
# arg[3]
|
|
cmp $3, %r13
|
|
jle .idone
|
|
movq 72(%r12), %rcx
|
|
|
|
# arg[4]
|
|
cmp $4, %r13
|
|
jle .idone
|
|
movq 80(%r12), %r8
|
|
|
|
# arg[5]
|
|
cmp $5, %r13
|
|
jle .idone
|
|
movq 88(%r12), %r9
|
|
|
|
.idone:
|
|
# Next, set up the fixed double arguments
|
|
# r13 = fixed double arg count
|
|
movq 8(%r12), %r13
|
|
|
|
# arg[0]
|
|
cmp $0, %r13
|
|
jle .vdone
|
|
movq 96(%r12), %xmm0
|
|
|
|
# arg[1]
|
|
cmp $1, %r13
|
|
jle .vdone
|
|
movq 104(%r12), %xmm1
|
|
|
|
# arg[2]
|
|
cmp $2, %r13
|
|
jle .vdone
|
|
movq 112(%r12), %xmm2
|
|
|
|
# arg[3]
|
|
cmp $3, %r13
|
|
jle .vdone
|
|
movq 120(%r12), %xmm3
|
|
|
|
# arg[4]
|
|
cmp $4, %r13
|
|
jle .vdone
|
|
movq 128(%r12), %xmm4
|
|
|
|
# arg[5]
|
|
cmp $5, %r13
|
|
jle .vdone
|
|
movq 136(%r12), %xmm5
|
|
|
|
# arg[6]
|
|
cmp $6, %r13
|
|
jle .vdone
|
|
movq 144(%r12), %xmm6
|
|
|
|
# arg[7]
|
|
cmp $7, %r13
|
|
jle .vdone
|
|
movq 152(%r12), %xmm7
|
|
|
|
.vdone:
|
|
# Finally, set up the variable arguments
|
|
|
|
# x8 = excess arg count
|
|
movq 32(%r12), %r13
|
|
|
|
# calculate the amount of stack space needed for the varargs
|
|
shl $3, %r13
|
|
|
|
andq $0xFFFFFFFFFFFFFFF0, %r13
|
|
addq $0x10, %r13
|
|
|
|
# allocate the stack space
|
|
sub %r13, %rsp
|
|
mov %rsp, %r14
|
|
|
|
# convert buffer size back to number of arguments
|
|
movq 32(%r12), %r13
|
|
|
|
# r13: number of var args (decrements with every iteration)
|
|
# r14: var arg dest pointer (increments with every iteration)
|
|
# r15: arg src buffer (increments with every iteration)
|
|
mov 160(%r12), %r15
|
|
|
|
.loop:
|
|
cmp $0, %r13
|
|
je .loop_end
|
|
|
|
# read the arg value from the src pointer
|
|
mov (%r15), %rax
|
|
|
|
# write it to the stack, and increment the dest pointer
|
|
mov %rax, (%r14)
|
|
add $8, %r14
|
|
|
|
# increment the src pointer, decrement the arg count
|
|
sub $1, %r13
|
|
add $8, %r15
|
|
|
|
jmp .loop
|
|
.loop_end:
|
|
|
|
# call the function implementation
|
|
mov 168(%r12), %rax
|
|
call *%r11
|
|
|
|
# de-allocate the stack varargs buffer (the size is now stored in x19)
|
|
movq 32(%r12), %r13
|
|
shl $3, %r13
|
|
andq $0xFFFFFFFFFFFFFFF0, %r13
|
|
addq $0x10, %r13
|
|
addq %r13, %rsp
|
|
|
|
pop %r15
|
|
pop %r14
|
|
pop %r13
|
|
pop %r12
|
|
|
|
# restore the saved stack frame and link pointer
|
|
pop %rbp
|
|
ret
|
|
|
|
|
|
.global callvm_invoke_d
|
|
.type callvm_invoke_d, @function
|
|
|
|
# %rdi = (function ptr) impl
|
|
# %rsi = (struct callvm *) context
|
|
callvm_invoke_d:
|
|
jmp callvm_invoke_i
|
|
|
|
|
|
.global callvm_invoke_v
|
|
.type callvm_invoke_v, @function
|
|
|
|
# %rdi = (function ptr) impl
|
|
# %rsi = (struct callvm *) context
|
|
callvm_invoke_v:
|
|
jmp callvm_invoke_i
|