iOS, add gcc3 helper for ARM64

Change-Id: Iad8cfd72803864bd1c8a5d01c74e1f856c27685d

3 files changed, 6 insertions, 964 deletions

diff --git a/bridges/Library_cpp_uno.mk b/bridges/Library_cpp_uno.mk
index 26aaf59ff8f1..73744d2d682c 100644
--- a/bridges/Library_cpp_uno.mk
+++ b/bridges/Library_cpp_uno.mk
@@ -21,6 +21,12 @@ $(call gb_LinkTarget_get_target,$(call gb_Library_get_linktarget,gcc3_uno)) : \
 	EXTRAOBJECTLISTS += $(call gb_CustomTarget_get_workdir,bridges/source/cpp_uno/gcc3_linux_arm)/armhelper.objectlist
 endif
 
+else ifeq ($(CPUNAME),ARM64)
+
+bridges_SELECTED_BRIDGE := gcc3_ios
+bridge_noopt_objects := abi call callvirtualmethod cpp2uno except uno2cpp
+bridge_asm_objects := ios64_helper
+
 else ifeq ($(CPUNAME),AARCH64)
 
 ifneq ($(filter ANDROID DRAGONFLY FREEBSD LINUX NETBSD OPENBSD,$(OS)),)
diff --git a/bridges/source/cpp_uno/gcc3_ios/cpp2uno-simulator.cxx b/bridges/source/cpp_uno/gcc3_ios/cpp2uno-simulator.cxx
deleted file mode 100644
index d350d0c4c3e1..000000000000
--- a/bridges/source/cpp_uno/gcc3_ios/cpp2uno-simulator.cxx
+++ /dev/null
@@ -1,520 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * This file is part of the LibreOffice project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * This file incorporates work covered by the following license notice:
- *
- *   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 .
- */
-#ifndef __arm64
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <rtl/alloc.h>
-#include <sal/log.hxx>
-
-#include <com/sun/star/uno/genfunc.hxx>
-#include "com/sun/star/uno/RuntimeException.hpp"
-#include <uno/data.h>
-#include <typelib/typedescription.hxx>
-
-#include "bridge.hxx"
-#include "cppinterfaceproxy.hxx"
-#include "types.hxx"
-#include "vtablefactory.hxx"
-
-#include "abi.hxx"
-#include "call.hxx"
-#include "share.hxx"
-
-using namespace ::osl;
-using namespace ::com::sun::star::uno;
-
-
-// Perform the UNO call
-//
-// We must convert the parameters stored in gpreg, fpreg and ovrflw to UNO
-// arguments and call pThis->getUnoI()->pDispatcher.
-//
-// gpreg:  [ret *], this, [gpr params]
-// fpreg:  [fpr params]
-// ovrflw: [gpr or fpr params (properly aligned)]
-//
-// [ret *] is present when we are returning a structure bigger than 16 bytes
-// Simple types are returned in rax, rdx (int), or xmm0, xmm1 (fp).
-// Similarly structures <= 16 bytes are in rax, rdx, xmm0, xmm1 as necessary.
-static typelib_TypeClass cpp2uno_call(
-    bridges::cpp_uno::shared::CppInterfaceProxy * pThis,
-    const typelib_TypeDescription * pMemberTypeDescr,
-    typelib_TypeDescriptionReference * pReturnTypeRef, // 0 indicates void return
-    sal_Int32 nParams, typelib_MethodParameter * pParams,
-    void ** gpreg, void ** fpreg, void ** ovrflw,
-    sal_uInt64 * pRegisterReturn /* space for register return */ )
-{
-    unsigned int nr_gpr = 0; //number of gpr registers used
-    unsigned int nr_fpr = 0; //number of fpr registers used
-
-    // return
-    typelib_TypeDescription * pReturnTypeDescr = nullptr;
-    if (pReturnTypeRef)
-        TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
-
-    void * pUnoReturn = nullptr;
-    void * pCppReturn = nullptr; // complex return ptr: if != 0 && != pUnoReturn, reconversion need
-
-    if ( pReturnTypeDescr )
-    {
-        if ( x86_64::return_in_hidden_param( pReturnTypeRef ) )
-        {
-            pCppReturn = *gpreg++;
-            nr_gpr++;
-
-            pUnoReturn = ( bridges::cpp_uno::shared::relatesToInterfaceType( pReturnTypeDescr )
-                           ? alloca( pReturnTypeDescr->nSize )
-                           : pCppReturn ); // direct way
-        }
-        else
-            pUnoReturn = pRegisterReturn; // direct way for simple types
-    }
-
-    // pop this
-    gpreg++;
-    nr_gpr++;
-
-    // stack space
-    // parameters
-    void ** pUnoArgs = static_cast<void **>(alloca( 4 * sizeof(void *) * nParams ));
-    void ** pCppArgs = pUnoArgs + nParams;
-    // indices of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndices = reinterpret_cast<sal_Int32 *>(pUnoArgs + (2 * nParams));
-    // type descriptions for reconversions
-    typelib_TypeDescription ** ppTempParamTypeDescr = reinterpret_cast<typelib_TypeDescription **>(pUnoArgs + (3 * nParams));
-
-    sal_Int32 nTempIndices = 0;
-
-    for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
-    {
-        const typelib_MethodParameter & rParam = pParams[nPos];
-
-        int nUsedGPR = 0;
-        int nUsedSSE = 0;
-#if OSL_DEBUG_LEVEL > 0
-        bool bFitsRegisters =
-#endif
-            x86_64::examine_argument( rParam.pTypeRef, false, nUsedGPR, nUsedSSE );
-        if ( !rParam.bOut && bridges::cpp_uno::shared::isSimpleType( rParam.pTypeRef ) ) // value
-        {
-            // Simple types must fit exactly one register on x86_64
-            assert(bFitsRegisters && ( ( nUsedSSE == 1 && nUsedGPR == 0 ) || ( nUsedSSE == 0 && nUsedGPR == 1 ) ));
-
-            if ( nUsedSSE == 1 )
-            {
-                if ( nr_fpr < x86_64::MAX_SSE_REGS )
-                {
-                    pCppArgs[nPos] = pUnoArgs[nPos] = fpreg++;
-                    nr_fpr++;
-                }
-                else
-                    pCppArgs[nPos] = pUnoArgs[nPos] = ovrflw++;
-            }
-            else if ( nUsedGPR == 1 )
-            {
-                if ( nr_gpr < x86_64::MAX_GPR_REGS )
-                {
-                    pCppArgs[nPos] = pUnoArgs[nPos] = gpreg++;
-                    nr_gpr++;
-                }
-                else
-                    pCppArgs[nPos] = pUnoArgs[nPos] = ovrflw++;
-            }
-        }
-        else // struct <= 16 bytes || ptr to complex value || ref
-        {
-            typelib_TypeDescription * pParamTypeDescr = nullptr;
-            TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
-
-            void *pCppStack;
-            if ( nr_gpr < x86_64::MAX_GPR_REGS )
-            {
-                pCppArgs[nPos] = pCppStack = *gpreg++;
-                nr_gpr++;
-            }
-            else
-                pCppArgs[nPos] = pCppStack = *ovrflw++;
-
-            if (! rParam.bIn) // is pure out
-            {
-                // uno out is unconstructed mem!
-                pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                pTempIndices[nTempIndices] = nPos;
-                // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
-            }
-            else if ( bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ) ) // is in/inout
-            {
-                uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
-                                        pCppStack, pParamTypeDescr,
-                                        pThis->getBridge()->getCpp2Uno() );
-                pTempIndices[nTempIndices] = nPos; // has to be reconverted
-                // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
-            }
-            else // direct way
-            {
-                pUnoArgs[nPos] = pCppStack;
-                // no longer needed
-                TYPELIB_DANGER_RELEASE( pParamTypeDescr );
-            }
-        }
-    }
-
-    // ExceptionHolder
-    uno_Any aUnoExc; // Any will be constructed by callee
-    uno_Any * pUnoExc = &aUnoExc;
-
-    // invoke uno dispatch call
-    (*pThis->getUnoI()->pDispatcher)( pThis->getUnoI(), pMemberTypeDescr, pUnoReturn, pUnoArgs, &pUnoExc );
-
-    // in case an exception occurred...
-    if ( pUnoExc )
-    {
-        // destruct temporary in/inout params
-        for ( ; nTempIndices--; )
-        {
-            sal_Int32 nIndex = pTempIndices[nTempIndices];
-
-            if (pParams[nIndex].bIn) // is in/inout => was constructed
-                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], nullptr );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
-        }
-        if (pReturnTypeDescr)
-            TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
-
-        CPPU_CURRENT_NAMESPACE::raiseException( &aUnoExc, pThis->getBridge()->getUno2Cpp() ); // has to destruct the any
-        // is here for dummy
-        return typelib_TypeClass_VOID;
-    }
-    else // else no exception occurred...
-    {
-        // temporary params
-        for ( ; nTempIndices--; )
-        {
-            sal_Int32 nIndex = pTempIndices[nTempIndices];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
-
-            if ( pParams[nIndex].bOut ) // inout/out
-            {
-                // convert and assign
-                uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
-                uno_copyAndConvertData( pCppArgs[nIndex], pUnoArgs[nIndex], pParamTypeDescr,
-                                        pThis->getBridge()->getUno2Cpp() );
-            }
-            // destroy temp uno param
-            uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, nullptr );
-
-            TYPELIB_DANGER_RELEASE( pParamTypeDescr );
-        }
-        // return
-        if ( pCppReturn ) // has complex return
-        {
-            if ( pUnoReturn != pCppReturn ) // needs reconversion
-            {
-                uno_copyAndConvertData( pCppReturn, pUnoReturn, pReturnTypeDescr,
-                                        pThis->getBridge()->getUno2Cpp() );
-                // destroy temp uno return
-                uno_destructData( pUnoReturn, pReturnTypeDescr, nullptr );
-            }
-            // complex return ptr is set to return reg
-            *reinterpret_cast<void **>(pRegisterReturn) = pCppReturn;
-        }
-        if ( pReturnTypeDescr )
-        {
-            typelib_TypeClass eRet = pReturnTypeDescr->eTypeClass;
-            TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
-            return eRet;
-        }
-        else
-            return typelib_TypeClass_VOID;
-    }
-}
-
-typelib_TypeClass cpp_vtable_call(
-    sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset,
-    void ** gpreg, void ** fpreg, void ** ovrflw,
-    sal_uInt64 * pRegisterReturn /* space for register return */ )
-{
-    // gpreg:  [ret *], this, [other gpr params]
-    // fpreg:  [fpr params]
-    // ovrflw: [gpr or fpr params (properly aligned)]
-    void * pThis;
-    if ( nFunctionIndex & 0x80000000 )
-    {
-        nFunctionIndex &= 0x7fffffff;
-        pThis = gpreg[1];
-    }
-    else
-    {
-        pThis = gpreg[0];
-    }
-    pThis = static_cast<char *>( pThis ) - nVtableOffset;
-
-    bridges::cpp_uno::shared::CppInterfaceProxy * pCppI =
-        bridges::cpp_uno::shared::CppInterfaceProxy::castInterfaceToProxy( pThis );
-
-    typelib_InterfaceTypeDescription * pTypeDescr = pCppI->getTypeDescr();
-
-    if ( nFunctionIndex >= pTypeDescr->nMapFunctionIndexToMemberIndex )
-    {
-        SAL_WARN(
-            "bridges",
-            "illegal " << OUString::unacquired(&pTypeDescr->aBase.pTypeName)
-                << " vtable index " << nFunctionIndex << "/"
-                << pTypeDescr->nMapFunctionIndexToMemberIndex);
-        throw RuntimeException(
-            ("illegal " + OUString::unacquired(&pTypeDescr->aBase.pTypeName)
-             + " vtable index " + OUString::number(nFunctionIndex) + "/"
-             + OUString::number(pTypeDescr->nMapFunctionIndexToMemberIndex)),
-            reinterpret_cast<XInterface *>( pCppI ) );
-    }
-
-    // determine called method
-    sal_Int32 nMemberPos = pTypeDescr->pMapFunctionIndexToMemberIndex[nFunctionIndex];
-    assert(nMemberPos < pTypeDescr->nAllMembers);
-
-    TypeDescription aMemberDescr( pTypeDescr->ppAllMembers[nMemberPos] );
-
-    typelib_TypeClass eRet;
-    switch ( aMemberDescr.get()->eTypeClass )
-    {
-        case typelib_TypeClass_INTERFACE_ATTRIBUTE:
-        {
-            typelib_TypeDescriptionReference *pAttrTypeRef =
-                reinterpret_cast<typelib_InterfaceAttributeTypeDescription *>( aMemberDescr.get() )->pAttributeTypeRef;
-
-            if ( pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos] == nFunctionIndex )
-            {
-                // is GET method
-                eRet = cpp2uno_call( pCppI, aMemberDescr.get(), pAttrTypeRef,
-                        0, nullptr, // no params
-                        gpreg, fpreg, ovrflw, pRegisterReturn );
-            }
-            else
-            {
-                // is SET method
-                typelib_MethodParameter aParam;
-                aParam.pTypeRef = pAttrTypeRef;
-                aParam.bIn      = true;
-                aParam.bOut     = false;
-
-                eRet = cpp2uno_call( pCppI, aMemberDescr.get(),
-                        nullptr, // indicates void return
-                        1, &aParam,
-                        gpreg, fpreg, ovrflw, pRegisterReturn );
-            }
-            break;
-        }
-        case typelib_TypeClass_INTERFACE_METHOD:
-        {
-            // is METHOD
-            switch ( nFunctionIndex )
-            {
-                case 1: // acquire()
-                    pCppI->acquireProxy(); // non virtual call!
-                    eRet = typelib_TypeClass_VOID;
-                    break;
-                case 2: // release()
-                    pCppI->releaseProxy(); // non virtual call!
-                    eRet = typelib_TypeClass_VOID;
-                    break;
-                case 0: // queryInterface() opt
-                {
-                    typelib_TypeDescription * pTD = nullptr;
-                    TYPELIB_DANGER_GET( &pTD, static_cast<Type *>( gpreg[2] )->getTypeLibType() );
-                    if ( pTD )
-                    {
-                        XInterface * pInterface = nullptr;
-                        (*pCppI->getBridge()->getCppEnv()->getRegisteredInterface)
-                            ( pCppI->getBridge()->getCppEnv(),
-                              reinterpret_cast<void **>(&pInterface),
-                              pCppI->getOid().pData,
-                              reinterpret_cast<typelib_InterfaceTypeDescription *>( pTD ) );
-
-                        if ( pInterface )
-                        {
-                            ::uno_any_construct( static_cast<uno_Any *>( gpreg[0] ),
-                                                 &pInterface, pTD, cpp_acquire );
-
-                            pInterface->release();
-                            TYPELIB_DANGER_RELEASE( pTD );
-
-                            reinterpret_cast<void **>( pRegisterReturn )[0] = gpreg[0];
-                            eRet = typelib_TypeClass_ANY;
-                            break;
-                        }
-                        TYPELIB_DANGER_RELEASE( pTD );
-                    }
-                    SAL_FALLTHROUGH; // else perform queryInterface()
-                }
-                default:
-                {
-                    typelib_InterfaceMethodTypeDescription *pMethodTD =
-                        reinterpret_cast<typelib_InterfaceMethodTypeDescription *>( aMemberDescr.get() );
-
-                    eRet = cpp2uno_call( pCppI, aMemberDescr.get(),
-                                         pMethodTD->pReturnTypeRef,
-                                         pMethodTD->nParams,
-                                         pMethodTD->pParams,
-                                         gpreg, fpreg, ovrflw, pRegisterReturn );
-                }
-            }
-            break;
-        }
-        default:
-        {
-            throw RuntimeException("no member description found!",
-                                    reinterpret_cast<XInterface *>( pCppI ) );
-        }
-    }
-
-    return eRet;
-}
-
-const int codeSnippetSize = 24;
-
-// Generate a trampoline that redirects method calls to
-// privateSnippetExecutor().
-//
-// privateSnippetExecutor() saves all the registers that are used for
-// parameter passing on x86_64, and calls the cpp_vtable_call().
-// When it returns, privateSnippetExecutor() sets the return value.
-//
-// Note: The code snippet we build here must not create a stack frame,
-// otherwise the UNO exceptions stop working thanks to non-existing
-// unwinding info.
-unsigned char * codeSnippet( unsigned char * code,
-        sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset,
-        bool bHasHiddenParam )
-{
-    sal_uInt64 nOffsetAndIndex = ( ( (sal_uInt64) nVtableOffset ) << 32 ) | ( (sal_uInt64) nFunctionIndex );
-
-    if ( bHasHiddenParam )
-        nOffsetAndIndex |= 0x80000000;
-
-    // movq $<nOffsetAndIndex>, %r10
-    *reinterpret_cast<sal_uInt16 *>( code ) = 0xba49;
-    *reinterpret_cast<sal_uInt16 *>( code + 2 ) = nOffsetAndIndex & 0xFFFF;
-    *reinterpret_cast<sal_uInt32 *>( code + 4 ) = nOffsetAndIndex >> 16;
-    *reinterpret_cast<sal_uInt16 *>( code + 8 ) = nOffsetAndIndex >> 48;
-
-    // movq $<address of the privateSnippetExecutor>, %r11
-    *reinterpret_cast<sal_uInt16 *>( code + 10 ) = 0xbb49;
-    *reinterpret_cast<sal_uInt32 *>( code + 12 )
-        = reinterpret_cast<sal_uInt64>(privateSnippetExecutor);
-    *reinterpret_cast<sal_uInt32 *>( code + 16 )
-        = reinterpret_cast<sal_uInt64>(privateSnippetExecutor) >> 32;
-
-    // jmpq *%r11
-    *reinterpret_cast<sal_uInt32 *>( code + 20 ) = 0x00e3ff49;
-
-#if OSL_DEBUG_LEVEL > 1
-    fprintf(stderr,
-            "==> codeSnippet, functionIndex=%d%s, vtableOffset=%d\n",
-            nFunctionIndex, (bHasHiddenParam ? "|0x80000000":""), nVtableOffset);
-#endif
-
-    return code + codeSnippetSize;
-}
-
-struct bridges::cpp_uno::shared::VtableFactory::Slot { void * fn; };
-
-bridges::cpp_uno::shared::VtableFactory::Slot *
-bridges::cpp_uno::shared::VtableFactory::mapBlockToVtable(void * block)
-{
-    return static_cast< Slot * >(block) + 2;
-}
-
-std::size_t bridges::cpp_uno::shared::VtableFactory::getBlockSize(
-    sal_Int32 slotCount)
-{
-    return (slotCount + 2) * sizeof (Slot) + slotCount * codeSnippetSize;
-}
-
-bridges::cpp_uno::shared::VtableFactory::Slot *
-bridges::cpp_uno::shared::VtableFactory::initializeBlock(
-    void * block, sal_Int32 slotCount, sal_Int32,
-    typelib_InterfaceTypeDescription *)
-{
-    Slot * slots = mapBlockToVtable(block);
-    slots[-2].fn = nullptr;
-    slots[-1].fn = nullptr;
-    return slots + slotCount;
-}
-
-
-unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
-    Slot ** slots, unsigned char * code,
-    typelib_InterfaceTypeDescription const * type, sal_Int32 nFunctionOffset,
-    sal_Int32 functionCount, sal_Int32 nVtableOffset )
-{
-    const sal_PtrDiff writetoexecdiff = 0;
-    (*slots) -= functionCount;
-    Slot * s = *slots;
-    for ( sal_Int32 nPos = 0; nPos < type->nMembers; ++nPos )
-    {
-        typelib_TypeDescription * pTD = nullptr;
-
-        TYPELIB_DANGER_GET( &pTD, type->ppMembers[ nPos ] );
-        assert(pTD);
-
-        if ( typelib_TypeClass_INTERFACE_ATTRIBUTE == pTD->eTypeClass )
-        {
-            typelib_InterfaceAttributeTypeDescription *pAttrTD =
-                reinterpret_cast<typelib_InterfaceAttributeTypeDescription *>( pTD );
-
-            // get method
-            (s++)->fn = code + writetoexecdiff;
-            code = codeSnippet( code, nFunctionOffset++, nVtableOffset,
-                                x86_64::return_in_hidden_param( pAttrTD->pAttributeTypeRef ) );
-
-            if ( ! pAttrTD->bReadOnly )
-            {
-                // set method
-                (s++)->fn = code + writetoexecdiff;
-                code = codeSnippet( code, nFunctionOffset++, nVtableOffset, false );
-            }
-        }
-        else if ( typelib_TypeClass_INTERFACE_METHOD == pTD->eTypeClass )
-        {
-            typelib_InterfaceMethodTypeDescription *pMethodTD =
-                reinterpret_cast<typelib_InterfaceMethodTypeDescription *>( pTD );
-
-            (s++)->fn = code + writetoexecdiff;
-            code = codeSnippet( code, nFunctionOffset++, nVtableOffset,
-                                x86_64::return_in_hidden_param( pMethodTD->pReturnTypeRef ) );
-        }
-        else
-            assert(false);
-
-        TYPELIB_DANGER_RELEASE( pTD );
-    }
-    return code;
-}
-
-void bridges::cpp_uno::shared::VtableFactory::flushCode(
-    SAL_UNUSED_PARAMETER unsigned char const *,
-    SAL_UNUSED_PARAMETER unsigned char const * )
-{}
-
-#endif
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/bridges/source/cpp_uno/gcc3_ios/uno2cpp-simulator.cxx b/bridges/source/cpp_uno/gcc3_ios/uno2cpp-simulator.cxx
deleted file mode 100644
index de032c3cca1d..000000000000
--- a/bridges/source/cpp_uno/gcc3_ios/uno2cpp-simulator.cxx
+++ /dev/null
@@ -1,444 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * This file is part of the LibreOffice project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * This file incorporates work covered by the following license notice:
- *
- *   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 .
- */
-#ifdef __x86_64
-
-#include <sal/alloca.h>
-
-#include <exception>
-#include <typeinfo>
-
-#include "rtl/alloc.h"
-
-#include <com/sun/star/uno/genfunc.hxx>
-#include "com/sun/star/uno/RuntimeException.hpp"
-#include <o3tl/runtimetooustring.hxx>
-#include <uno/data.h>
-
-#include <bridge.hxx>
-#include <types.hxx>
-#include "unointerfaceproxy.hxx"
-#include "vtables.hxx"
-
-#include "abi.hxx"
-#include "callvirtualmethod.hxx"
-#include "share.hxx"
-
-using namespace ::com::sun::star::uno;
-
-namespace {
-
-// Functions for easier insertion of values to registers or stack
-// pSV - pointer to the source
-// nr - order of the value [will be increased if stored to register]
-// pFPR, pGPR - pointer to the registers
-// pDS - pointer to the stack [will be increased if stored here]
-
-// The value in %xmm register is already prepared to be retrieved as a float,
-// thus we treat float and double the same
-void INSERT_FLOAT_DOUBLE(
-    void const * pSV, sal_uInt32 & nr, double * pFPR, sal_uInt64 *& pDS)
-{
-    if ( nr < x86_64::MAX_SSE_REGS )
-        pFPR[nr++] = *static_cast<double const *>( pSV );
-    else
-        *pDS++ = *static_cast<sal_uInt64 const *>( pSV ); // verbatim!
-}
-
-void INSERT_INT64(
-    void const * pSV, sal_uInt32 & nr, sal_uInt64 * pGPR, sal_uInt64 *& pDS)
-{
-    if ( nr < x86_64::MAX_GPR_REGS )
-        pGPR[nr++] = *static_cast<sal_uInt64 const *>( pSV );
-    else
-        *pDS++ = *static_cast<sal_uInt64 const *>( pSV );
-}
-
-void INSERT_INT32(
-    void const * pSV, sal_uInt32 & nr, sal_uInt64 * pGPR, sal_uInt64 *& pDS)
-{
-    if ( nr < x86_64::MAX_GPR_REGS )
-        pGPR[nr++] = *static_cast<sal_uInt32 const *>( pSV );
-    else
-        *pDS++ = *static_cast<sal_uInt32 const *>( pSV );
-}
-
-void INSERT_INT16(
-    void const * pSV, sal_uInt32 & nr, sal_uInt64 * pGPR, sal_uInt64 *& pDS)
-{
-    if ( nr < x86_64::MAX_GPR_REGS )
-        pGPR[nr++] = *static_cast<sal_uInt16 const *>( pSV );
-    else
-        *pDS++ = *static_cast<sal_uInt16 const *>( pSV );
-}
-
-void INSERT_INT8(
-    void const * pSV, sal_uInt32 & nr, sal_uInt64 * pGPR, sal_uInt64 *& pDS)
-{
-    if ( nr < x86_64::MAX_GPR_REGS )
-        pGPR[nr++] = *static_cast<sal_uInt8 const *>( pSV );
-    else
-        *pDS++ = *static_cast<sal_uInt8 const *>( pSV );
-}
-
-}
-
-static void cpp_call(
-    bridges::cpp_uno::shared::UnoInterfaceProxy * pThis,
-    bridges::cpp_uno::shared::VtableSlot aVtableSlot,
-    typelib_TypeDescriptionReference * pReturnTypeRef,
-    sal_Int32 nParams, typelib_MethodParameter * pParams,
-    void * pUnoReturn, void * pUnoArgs[], uno_Any ** ppUnoExc )
-{
-    // Maximum space for [complex ret ptr], values | ptr ...
-    // (but will be used less - some of the values will be in pGPR and pFPR)
-      sal_uInt64 *pStack = static_cast<sal_uInt64 *>(__builtin_alloca( (nParams + 3) * sizeof(sal_uInt64) ));
-      sal_uInt64 *pStackStart = pStack;
-
-    sal_uInt64 pGPR[x86_64::MAX_GPR_REGS];
-    sal_uInt32 nGPR = 0;
-
-    double pFPR[x86_64::MAX_SSE_REGS];
-    sal_uInt32 nFPR = 0;
-
-    // Return
-    typelib_TypeDescription * pReturnTypeDescr = nullptr;
-    TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
-    assert(pReturnTypeDescr);
-
-    void * pCppReturn = nullptr; // if != 0 && != pUnoReturn, needs reconversion (see below)
-
-    bool bSimpleReturn = true;
-    if ( pReturnTypeDescr )
-    {
-        if ( x86_64::return_in_hidden_param( pReturnTypeRef ) )
-            bSimpleReturn = false;
-
-        if ( bSimpleReturn )
-            pCppReturn = pUnoReturn; // direct way for simple types
-        else
-        {
-            // complex return via ptr
-            pCppReturn = bridges::cpp_uno::shared::relatesToInterfaceType( pReturnTypeDescr )?
-                         __builtin_alloca( pReturnTypeDescr->nSize ) : pUnoReturn;
-            INSERT_INT64( &pCppReturn, nGPR, pGPR, pStack );
-        }
-    }
-
-    // Push "this" pointer
-    void * pAdjustedThisPtr = reinterpret_cast< void ** >( pThis->getCppI() ) + aVtableSlot.offset;
-    INSERT_INT64( &pAdjustedThisPtr, nGPR, pGPR, pStack );
-
-    // Args
-    void ** pCppArgs = static_cast<void **>(alloca( 3 * sizeof(void *) * nParams ));
-    // Indices of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndices = reinterpret_cast<sal_Int32 *>(pCppArgs + nParams);
-    // Type descriptions for reconversions
-    typelib_TypeDescription ** ppTempParamTypeDescr = reinterpret_cast<typelib_TypeDescription **>(pCppArgs + (2 * nParams));
-
-    sal_Int32 nTempIndices = 0;
-
-    for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
-    {
-        const typelib_MethodParameter & rParam = pParams[nPos];
-        typelib_TypeDescription * pParamTypeDescr = nullptr;
-        TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
-
-        if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
-        {
-            uno_copyAndConvertData( pCppArgs[nPos] = alloca( 8 ), pUnoArgs[nPos], pParamTypeDescr,
-                                    pThis->getBridge()->getUno2Cpp() );
-
-            switch (pParamTypeDescr->eTypeClass)
-            {
-            case typelib_TypeClass_HYPER:
-            case typelib_TypeClass_UNSIGNED_HYPER:
-                INSERT_INT64( pCppArgs[nPos], nGPR, pGPR, pStack );
-                break;
-            case typelib_TypeClass_LONG:
-            case typelib_TypeClass_UNSIGNED_LONG:
-            case typelib_TypeClass_ENUM:
-                INSERT_INT32( pCppArgs[nPos], nGPR, pGPR, pStack );
-                break;
-            case typelib_TypeClass_SHORT:
-            case typelib_TypeClass_CHAR:
-            case typelib_TypeClass_UNSIGNED_SHORT:
-                INSERT_INT16( pCppArgs[nPos], nGPR, pGPR, pStack );
-                break;
-            case typelib_TypeClass_BOOLEAN:
-            case typelib_TypeClass_BYTE:
-                INSERT_INT8( pCppArgs[nPos], nGPR, pGPR, pStack );
-                break;
-            case typelib_TypeClass_FLOAT:
-            case typelib_TypeClass_DOUBLE:
-                INSERT_FLOAT_DOUBLE( pCppArgs[nPos], nFPR, pFPR, pStack );
-                break;
-            default:
-                break;
-            }
-
-            // no longer needed
-            TYPELIB_DANGER_RELEASE( pParamTypeDescr );
-        }
-        else // ptr to complex value | ref
-        {
-            if (! rParam.bIn) // is pure out
-            {
-                // cpp out is constructed mem, uno out is not!
-                uno_constructData(
-                    pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
-                    pParamTypeDescr );
-                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
-                // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
-            }
-            // is in/inout
-            else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
-            {
-                uno_copyAndConvertData(
-                    pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
-                    pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
-
-                pTempIndices[nTempIndices] = nPos; // has to be reconverted
-                // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
-            }
-            else // direct way
-            {
-                pCppArgs[nPos] = pUnoArgs[nPos];
-                // no longer needed
-                TYPELIB_DANGER_RELEASE( pParamTypeDescr );
-            }
-            INSERT_INT64( &(pCppArgs[nPos]), nGPR, pGPR, pStack );
-        }
-    }
-
-    try
-    {
-        try {
-            CPPU_CURRENT_NAMESPACE::callVirtualMethod(
-                pAdjustedThisPtr, aVtableSlot.index,
-                pCppReturn, pReturnTypeRef, bSimpleReturn,
-                pStackStart, ( pStack - pStackStart ),
-                pGPR, pFPR );
-        } catch (const Exception &) {
-            throw;
-        } catch (const std::exception & e) {
-            throw RuntimeException(
-                "C++ code threw " + o3tl::runtimeToOUString(typeid(e).name())
-                + ": " + o3tl::runtimeToOUString(e.what()));
-        } catch (...) {
-            throw RuntimeException("C++ code threw unknown exception");
-        }
-
-        *ppUnoExc = nullptr;
-
-        // reconvert temporary params
-        for ( ; nTempIndices--; )
-        {
-            sal_Int32 nIndex = pTempIndices[nTempIndices];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
-
-            if (pParams[nIndex].bIn)
-            {
-                if (pParams[nIndex].bOut) // inout
-                {
-                    uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, nullptr ); // destroy uno value
-                    uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
-                                            pThis->getBridge()->getCpp2Uno() );
-                }
-            }
-            else // pure out
-            {
-                uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
-                                        pThis->getBridge()->getCpp2Uno() );
-            }
-            // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
-
-            TYPELIB_DANGER_RELEASE( pParamTypeDescr );
-        }
-        // return value
-        if (pCppReturn && pUnoReturn != pCppReturn)
-        {
-            uno_copyAndConvertData( pUnoReturn, pCppReturn, pReturnTypeDescr,
-                                    pThis->getBridge()->getCpp2Uno() );
-            uno_destructData( pCppReturn, pReturnTypeDescr, cpp_release );
-        }
-    }
-     catch (...)
-     {
-          // fill uno exception
-        CPPU_CURRENT_NAMESPACE::fillUnoException( __cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
-
-        // temporary params
-        for ( ; nTempIndices--; )
-        {
-            sal_Int32 nIndex = pTempIndices[nTempIndices];
-            // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
-        }
-        // return type
-        if (pReturnTypeDescr)
-            TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
-    }
-}
-
-
-namespace bridges { namespace cpp_uno { namespace shared {
-
-void unoInterfaceProxyDispatch(
-    uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr,
-    void * pReturn, void * pArgs[], uno_Any ** ppException )
-{
-    // is my surrogate
-    bridges::cpp_uno::shared::UnoInterfaceProxy * pThis
-        = static_cast< bridges::cpp_uno::shared::UnoInterfaceProxy * >(pUnoI);
-#if OSL_DEBUG_LEVEL > 0
-    typelib_InterfaceTypeDescription * pTypeDescr = pThis->pTypeDescr;
-#endif
-
-    switch (pMemberDescr->eTypeClass)
-    {
-    case typelib_TypeClass_INTERFACE_ATTRIBUTE:
-    {
-#if OSL_DEBUG_LEVEL > 0
-        // determine vtable call index
-        sal_Int32 nMemberPos = reinterpret_cast<typelib_InterfaceMemberTypeDescription const *>(pMemberDescr)->nPosition;
-        assert(nMemberPos < pTypeDescr->nAllMembers);
-#endif
-        VtableSlot aVtableSlot(
-                getVtableSlot(
-                    reinterpret_cast<
-                    typelib_InterfaceAttributeTypeDescription const * >(
-                        pMemberDescr)));
-
-        if (pReturn)
-        {
-            // dependent dispatch
-            cpp_call(
-                pThis, aVtableSlot,
-                reinterpret_cast<typelib_InterfaceAttributeTypeDescription const *>(pMemberDescr)->pAttributeTypeRef,
-                0, nullptr, // no params
-                pReturn, pArgs, ppException );
-        }
-        else
-        {
-            // is SET
-            typelib_MethodParameter aParam;
-            aParam.pTypeRef =
-                reinterpret_cast<typelib_InterfaceAttributeTypeDescription const *>(pMemberDescr)->pAttributeTypeRef;
-            aParam.bIn      = true;
-            aParam.bOut     = false;
-
-            typelib_TypeDescriptionReference * pReturnTypeRef = nullptr;
-            OUString aVoidName("void");
-            typelib_typedescriptionreference_new(
-                &pReturnTypeRef, typelib_TypeClass_VOID, aVoidName.pData );
-
-            // dependent dispatch
-            aVtableSlot.index += 1; // get, then set method
-            cpp_call(
-                pThis, aVtableSlot, // get, then set method
-                pReturnTypeRef,
-                1, &aParam,
-                pReturn, pArgs, ppException );
-
-            typelib_typedescriptionreference_release( pReturnTypeRef );
-        }
-
-        break;
-    }
-    case typelib_TypeClass_INTERFACE_METHOD:
-    {
-#if OSL_DEBUG_LEVEL > 0
-        // determine vtable call index
-        sal_Int32 nMemberPos = reinterpret_cast<typelib_InterfaceMemberTypeDescription const *>(pMemberDescr)->nPosition;
-        assert(nMemberPos < pTypeDescr->nAllMembers);
-#endif
-        VtableSlot aVtableSlot(
-                getVtableSlot(
-                    reinterpret_cast<
-                    typelib_InterfaceMethodTypeDescription const * >(
-                        pMemberDescr)));
-
-        switch (aVtableSlot.index)
-        {
-            // standard calls
-        case 1: // acquire uno interface
-            (*pUnoI->acquire)( pUnoI );
-            *ppException = nullptr;
-            break;
-        case 2: // release uno interface
-            (*pUnoI->release)( pUnoI );
-            *ppException = nullptr;
-            break;
-        case 0: // queryInterface() opt
-        {
-            typelib_TypeDescription * pTD = nullptr;
-            TYPELIB_DANGER_GET( &pTD, static_cast< Type * >( pArgs[0] )->getTypeLibType() );
-            if (pTD)
-            {
-                uno_Interface * pInterface = nullptr;
-                (*pThis->getBridge()->getUnoEnv()->getRegisteredInterface)(
-                    pThis->getBridge()->getUnoEnv(),
-                    reinterpret_cast<void **>(&pInterface), pThis->oid.pData, reinterpret_cast<typelib_InterfaceTypeDescription *>(pTD) );
-
-                if (pInterface)
-                {
-                    ::uno_any_construct(
-                        static_cast< uno_Any * >( pReturn ),
-                        &pInterface, pTD, nullptr );
-                    (*pInterface->release)( pInterface );
-                    TYPELIB_DANGER_RELEASE( pTD );
-                    *ppException = nullptr;
-                    break;
-                }
-                TYPELIB_DANGER_RELEASE( pTD );
-            }
-            SAL_FALLTHROUGH; // else perform queryInterface()
-        }
-        default:
-            // dependent dispatch
-            cpp_call(
-                pThis, aVtableSlot,
-                reinterpret_cast<typelib_InterfaceMethodTypeDescription const *>(pMemberDescr)->pReturnTypeRef,
-                reinterpret_cast<typelib_InterfaceMethodTypeDescription const *>(pMemberDescr)->nParams,
-                reinterpret_cast<typelib_InterfaceMethodTypeDescription const *>(pMemberDescr)->pParams,
-                pReturn, pArgs, ppException );
-        }
-        break;
-    }
-    default:
-    {
-        ::com::sun::star::uno::RuntimeException aExc(
-            "illegal member type description!",
-            ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >() );
-
-        Type const & rExcType = cppu::UnoType<decltype(aExc)>::get();
-        // binary identical null reference
-        ::uno_type_any_construct( *ppException, &aExc, rExcType.getTypeLibType(), nullptr );
-    }
-    }
-}
-
-} } }
-#endif
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */