xref: /AOO41X/main/bridges/source/cpp_uno/cc50_solaris_intel/call.s (revision d2748020ce41a64ef548fe1dae7ba98cbf99a183)

//**************************************************************
/ *
/ * Licensed to the Apache Software Foundation (ASF) under one
/ * or more contributor license agreements.  See the NOTICE file
/ * distributed with this work for additional information
/ * regarding copyright ownership.  The ASF licenses this file
/ * to you under the Apache License, Version 2.0 (the
/ * "License"); you may not use this file except in compliance
/ * with the License.  You may obtain a copy of the License at
/ *
/ *   http://www.apache.org/licenses/LICENSE-2.0
/ *
/ * Unless required by applicable law or agreed to in writing,
/ * software distributed under the License is distributed on an
/ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
/ * KIND, either express or implied.  See the License for the
/ * specific language governing permissions and limitations
/ * under the License.
/ *
/ *************************************************************/

    .align 4
    .globl privateSnippetExecutorGeneral
privateSnippetExecutorGeneral:
    movl    %esp,%ecx
    pushl   %ebp              / proper stack frame needed for exception handling
    movl    %esp,%ebp
    andl    $0xFFFFFFF8,%esp  / align following 64bit arg
    subl    $0x8,%esp         / 64bit nRegReturn
    pushl   %ecx              / 32bit pCallStack
    pushl   %edx              / 32bit nVtableOffset
    pushl   %eax              / 32bit nFunctionIndex
    call    cpp_vtable_call
    movl    12(%esp),%eax     / 64 bit nRegReturn, lower half
    leave
    ret
    .type privateSnippetExecutorGeneral, @function
    .size privateSnippetExecutorGeneral, .-privateSnippetExecutorGeneral

    .align 4
    .globl privateSnippetExecutorVoid
privateSnippetExecutorVoid:
    movl    %esp,%ecx
    pushl   %ebp              / proper stack frame needed for exception handling
    movl    %esp,%ebp
    andl    $0xFFFFFFF8,%esp  / align following 64bit arg
    subl    $0x8,%esp         / 64bit nRegReturn
    pushl   %ecx              / 32bit pCallStack
    pushl   %edx              / 32bit nVtableOffset
    pushl   %eax              / 32bit nFunctionIndex
    call    cpp_vtable_call
    leave
    ret
    .type privateSnippetExecutorVoid, @function
    .size privateSnippetExecutorVoid, .-privateSnippetExecutorVoid

    .align 4
    .globl privateSnippetExecutorHyper
privateSnippetExecutorHyper:
    movl    %esp,%ecx
    pushl   %ebp              / proper stack frame needed for exception handling
    movl    %esp,%ebp
    andl    $0xFFFFFFF8,%esp  / align following 64bit arg
    subl    $0x8,%esp         / 64bit nRegReturn
    pushl   %ecx              / 32bit pCallStack
    pushl   %edx              / 32bit nVtableOffset
    pushl   %eax              / 32bit nFunctionIndex
    call    cpp_vtable_call
    movl    12(%esp),%eax     / 64 bit nRegReturn, lower half
    movl    16(%esp),%edx     / 64 bit nRegReturn, upper half
    leave
    ret
    .type privateSnippetExecutorHyper, @function
    .size privateSnippetExecutorHyper, .-privateSnippetExecutorHyper

    .align 4
    .globl privateSnippetExecutorFloat
privateSnippetExecutorFloat:
    movl    %esp,%ecx
    pushl   %ebp              / proper stack frame needed for exception handling
    movl    %esp,%ebp
    andl    $0xFFFFFFF8,%esp  / align following 64bit arg
    subl    $0x8,%esp         / 64bit nRegReturn
    pushl   %ecx              / 32bit pCallStack
    pushl   %edx              / 32bit nVtableOffset
    pushl   %eax              / 32bit nFunctionIndex
    call    cpp_vtable_call
    flds    12(%esp)          / 64 bit nRegReturn, lower half
    leave
    ret
    .type privateSnippetExecutorFloat, @function
    .size privateSnippetExecutorFloat, .-privateSnippetExecutorFloat

    .align 4
    .globl privateSnippetExecutorDouble
privateSnippetExecutorDouble:
    movl    %esp,%ecx
    pushl   %ebp              / proper stack frame needed for exception handling
    movl    %esp,%ebp
    andl    $0xFFFFFFF8,%esp  / align following 64bit arg
    subl    $0x8,%esp         / 64bit nRegReturn
    pushl   %ecx              / 32bit pCallStack
    pushl   %edx              / 32bit nVtableOffset
    pushl   %eax              / 32bit nFunctionIndex
    call    cpp_vtable_call
    fldl    12(%esp)          / 64 bit nRegReturn
    leave
    ret
    .type privateSnippetExecutorDouble, @function
    .size privateSnippetExecutorDouble, .-privateSnippetExecutorDouble

    .align 4
    .globl privateSnippetExecutorStruct
privateSnippetExecutorStruct:
    movl    %esp,%ecx
    pushl   %ebp              / proper stack frame needed for exception handling
    movl    %esp,%ebp
    andl    $0xFFFFFFF8,%esp  / align following 64bit arg
    subl    $0x8,%esp         / 64bit nRegReturn
    pushl   %ecx              / 32bit pCallStack
    pushl   %edx              / 32bit nVtableOffset
    pushl   %eax              / 32bit nFunctionIndex
    call    cpp_vtable_call
    movl    12(%esp),%eax     / 64 bit nRegReturn, lower half
    leave
    ret     $4
    .type privateSnippetExecutorStruct, @function
    .size privateSnippetExecutorStruct, .-privateSnippetExecutorStruct

	.align 4
	.globl callVirtualMethod
callVirtualMethod:
	pushl	%ebp
	movl	%esp, %ebp
	subl	$24, %esp
	movl	%edx, -4(%ebp)
	movl	%ecx, -8(%ebp)
	movl	%eax, -12(%ebp)
	movl	%esp, -16(%ebp)
	movl	%ebx, -20(%ebp)

	/ set ebx to GOT
.L_GOT_BEGIN_2:
	call	.L_GOT_END_2
.L_GOT_END_2:
	popl	%ebx
	addl	$_GLOBAL_OFFSET_TABLE_+[.-.L_GOT_END_2],%ebx
.callBeginPosition:
	movl	28(%ebp), %eax
	movl	%eax, %edx
	dec		%edx
	shl		$2, %edx
	add		24(%ebp), %edx
.copyLong:
	movl	0(%edx), %ecx
	sub		$4, %edx
	push	%ecx
	dec		%eax
	jne		.copyLong
.doCall:
	movl	8(%ebp), %edx
	movl	0(%edx), %edx
	movl	12(%ebp), %eax
	add		$2, %eax
	shl		$2, %eax
	add		%eax, %edx
	movl	0(%edx), %edx

	call	*%edx

.callVirtualMethodExceptionPosition:
	/ handle returns
	movl	20(%ebp), %ecx

	/ byte types
	cmp     $2, %ecx	/ typelib_TypeClass_BOOLEAN
	je		.handleByte
	cmp		$3, %ecx
	je		.handleByte	/ typelib_TypeClass_BYTE

	/ half word types
	cmp    $4, %ecx		/ typelib_TypeClass_SHORT
	je     .handleShort
	cmp    $5, %ecx		/ typelib_TypeClass_UNSIGNED_SHORT
	je     .handleShort

	/ word types
	cmp    $6, %ecx		/ typelib_TypeClass_LONG
	je     .handleWord
	cmp    $7, %ecx		/ typelib_TypeClass_UNSIGNED_LONG
	je     .handleWord
	cmp    $1, %ecx		/ typelib_TypeClass_CHAR (wchar_t)
	je     .handleWord
	cmp    $15, %ecx	/ typelib_TypeClass_ENUM
	je     .handleWord

	/ double word types
	cmp    $8, %ecx		/ typelib_TypeClass_HYPER
	je     .handleDoubleWord
	cmp    $9, %ecx		/ typelib_TypeClass_UNSIGNED_HYPER
	je     .handleDoubleWord

	/ float
	cmp    $10, %ecx	/ typelib_TypeClass_FLOAT
	je     .handleFloat

	/ double
	cmp    $11, %ecx	/ typelib_TypeClass_DOUBLE
	je     .handleDouble

	/ default: return void
	jmp    .doRestore
.handleByte:
	movl	16(%ebp), %ecx
	movb	%al, 0(%ecx)
	jmp		.doRestore
.handleShort:
	movl	16(%ebp), %ecx
	movw	%ax, 0(%ecx)
	jmp		.doRestore
.handleWord:
	movl	16(%ebp), %ecx
	movl	%eax, 0(%ecx)
	jmp		.doRestore
.handleDoubleWord:
	movl	16(%ebp), %ecx
	movl	%eax, 0(%ecx)
	movl	%edx, 4(%ecx)
	jmp		.doRestore
.handleFloat:
	movl	16(%ebp), %ecx
	fstps	0(%ecx)
	jmp		.doRestore
.handleDouble:
	movl	16(%ebp), %ecx
	fstpl	0(%ecx)
	jmp		.doRestore
.doRestore:
	movl	-4(%ebp), %edx
	movl	-8(%ebp), %ecx
	movl	-12(%ebp), %eax
	movl	-20(%ebp), %ebx
	movl	%ebp, %esp
	popl	%ebp
	ret
	.type callVirtualMethod, @function
	.size callVirtualMethod, .-callVirtualMethod

	.globl callVirtualMethodExceptionHandler
callVirtualMethodExceptionHandler:
	movl	-4(%ebp), %edx
	movl	-8(%ebp), %ecx
	movl	-12(%ebp), %eax
	movl	-16(%ebp), %esp
	movl	-20(%ebp), %ebx
	call	__1cG__CrunMex_rethrow_q6F_v_@PLT
	ret

	.type callVirtualMethodExceptionHandler, @function
	.size callVirtualMethodExceptionHandler, .-callVirtualMethodExceptionHandler


	.section	.exception_ranges,"aw"
	.align		4

	.4byte		.callBeginPosition@rel
	.4byte		.callVirtualMethodExceptionPosition-.callBeginPosition
	.4byte		callVirtualMethodExceptionHandler-.callBeginPosition
	.zero		8