xref: /trunk/main/bridges/source/cpp_uno/gcc3_freebsd_aarch64/uno2cpp.cxx (revision 9c15e1abd703a7953928d7a80655ae1a76a41f6d)

/*
 * 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.
 */


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_bridges.hxx"

#include <exception>
#include <typeinfo>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "rtl/alloc.h"
#include "rtl/ustrbuf.hxx"

#include <com/sun/star/uno/genfunc.hxx>
#include "com/sun/star/uno/RuntimeException.hpp"
#include <uno/data.h>

#include <bridges/cpp_uno/shared/bridge.hxx>
#include <bridges/cpp_uno/shared/types.hxx>
#include "bridges/cpp_uno/shared/unointerfaceproxy.hxx"
#include "bridges/cpp_uno/shared/vtables.hxx"

#include "abi.hxx"
#include "share.hxx"

using namespace ::rtl;
using namespace ::com::sun::star::uno;

//==================================================================================================

// The AArch64 outgoing-call trampoline, implemented in call.s.  It loads the
// argument registers from the caller-prepared arrays, copies overflow args to
// the outgoing stack, performs the indirect call, and returns x0/x1 and d0..d3.
extern "C" void callVirtualFunction(
    sal_uInt64 pFunction, sal_uInt64 pIndirectRet,
    sal_uInt64 *pGPR, double *pFPR,
    unsigned char *pStack, sal_uInt32 nStackBytes,
    sal_uInt64 *pGPRReturn, double *pFPRReturn );

static void callVirtualMethod(void * pThis, sal_uInt32 nVtableIndex,
                              void * pRegisterReturn, typelib_TypeDescriptionReference * pReturnTypeRef, bool bSimpleReturn,
                              void * pIndirectReturn,
                              unsigned char *pStack, sal_uInt32 nStack,
                              sal_uInt64 *pGPR, sal_uInt32 nGPR,
                              double *pFPR, sal_uInt32 nFPR) __attribute__((noinline));

static void callVirtualMethod(void * pThis, sal_uInt32 nVtableIndex,
                              void * pRegisterReturn, typelib_TypeDescriptionReference * pReturnTypeRef, bool bSimpleReturn,
                              void * pIndirectReturn,
                               unsigned char *pStack, sal_uInt32 nStack,
                              sal_uInt64 *pGPR, sal_uInt32 nGPR,
                              double *pFPR, sal_uInt32 nFPR)
{
#if OSL_DEBUG_LEVEL > 1
    // Let's figure out what is really going on here
    {
        fprintf( stderr, "= callVirtualMethod() =\nGPR's (%d): ", nGPR );
        for ( unsigned int i = 0; i < nGPR; ++i )
            fprintf( stderr, "0x%lx, ", pGPR[i] );
        fprintf( stderr, "\nFPR's (%d): ", nFPR );
        for ( unsigned int i = 0; i < nFPR; ++i )
            fprintf( stderr, "%f, ", pFPR[i] );
        // The overflow area is a packed byte image, not an array of words.
        fprintf( stderr, "\nStack (%d bytes): ", nStack );
        for ( unsigned int i = 0; i < nStack; ++i )
            fprintf( stderr, "%02x ", pStack[i] );
        fprintf( stderr, "\n" );
    }
#endif

    // The call instruction within callVirtualFunction may throw exceptions.  So
    // that the compiler handles this correctly, it is important that (a)
    // callVirtualMethod might call dummy_can_throw_anything (although this never
    // happens at runtime), which in turn can throw exceptions, and (b)
    // callVirtualMethod is not inlined at its call site (so that any exceptions
    // thrown across the call are caught):
    if ( !pThis )
        CPPU_CURRENT_NAMESPACE::dummy_can_throw_anything( "xxx" ); // address something

    // Should not happen, but...
    if ( nFPR > aarch64::MAX_FPR_REGS )
        nFPR = aarch64::MAX_FPR_REGS;
    if ( nGPR > aarch64::MAX_GPR_REGS )
        nGPR = aarch64::MAX_GPR_REGS;

    // Get pointer to the C++ virtual method from the vtable.
    sal_uInt64 pMethod = *((sal_uInt64 *)pThis);
    pMethod += 8 * nVtableIndex;
    pMethod = *((sal_uInt64 *)pMethod);

    // Return register save areas: x0,x1 and d0..d3 (HFA up to 4 elements).
    sal_uInt64 gpReturn[2] = { 0, 0 };
    double fpReturn[4] = { 0, 0, 0, 0 };

    // Ensure the GPR/FPR arrays are the full register width even if fewer were
    // filled (the trampoline always loads all 8 of each).
    sal_uInt64 gpr[aarch64::MAX_GPR_REGS];
    double fpr[aarch64::MAX_FPR_REGS];
    for ( sal_uInt32 i = 0; i < aarch64::MAX_GPR_REGS; ++i )
        gpr[i] = ( i < nGPR ) ? pGPR[i] : 0;
    for ( sal_uInt32 i = 0; i < aarch64::MAX_FPR_REGS; ++i )
        fpr[i] = ( i < nFPR ) ? pFPR[i] : 0;

    callVirtualFunction(
        pMethod,
        reinterpret_cast<sal_uInt64>( pIndirectReturn ), // x8, 0 if none
        gpr, fpr,
        pStack, nStack,
        gpReturn, fpReturn );

    switch (pReturnTypeRef->eTypeClass)
    {
    case typelib_TypeClass_HYPER:
    case typelib_TypeClass_UNSIGNED_HYPER:
        *reinterpret_cast<sal_uInt64 *>( pRegisterReturn ) = gpReturn[0];
        break;
    case typelib_TypeClass_LONG:
        *reinterpret_cast<sal_Int32 *>( pRegisterReturn ) =
            *reinterpret_cast<sal_Int32 *>( &gpReturn[0] );
        break;
    case typelib_TypeClass_UNSIGNED_LONG:
    case typelib_TypeClass_ENUM:
        *reinterpret_cast<sal_uInt32 *>( pRegisterReturn ) =
            *reinterpret_cast<sal_uInt32 *>( &gpReturn[0] );
        break;
    case typelib_TypeClass_CHAR:
    case typelib_TypeClass_UNSIGNED_SHORT:
        *reinterpret_cast<sal_uInt16 *>( pRegisterReturn ) = *reinterpret_cast<sal_uInt16*>( &gpReturn[0] );
        break;
    case typelib_TypeClass_SHORT:
        *reinterpret_cast<sal_Int16 *>( pRegisterReturn ) =
            *reinterpret_cast<sal_Int16 *>( &gpReturn[0] );
        break;
    case typelib_TypeClass_BOOLEAN:
        *reinterpret_cast<sal_uInt8 *>( pRegisterReturn ) = *reinterpret_cast<sal_uInt8*>( &gpReturn[0] );
        break;
    case typelib_TypeClass_BYTE:
        *reinterpret_cast<sal_Int8 *>( pRegisterReturn ) =
            *reinterpret_cast<sal_Int8 *>( &gpReturn[0] );
        break;
    case typelib_TypeClass_FLOAT:
        *reinterpret_cast<float *>( pRegisterReturn ) =
            *reinterpret_cast<float *>( &fpReturn[0] );
        break;
    case typelib_TypeClass_DOUBLE:
        *reinterpret_cast<double *>( pRegisterReturn ) =
            *reinterpret_cast<double *>( &fpReturn[0] );
        break;
    case typelib_TypeClass_STRUCT:
    case typelib_TypeClass_EXCEPTION:
        aarch64::fill_struct( pReturnTypeRef, gpReturn, fpReturn, pRegisterReturn );
        break;
    default:
        break;
    }
}

//==================================================================================================
// The AArch64 outgoing-call trampoline, implemented in call.s, is declared in ABI
// and used by callVirtualMethod above. The rest of the file implements the
// public callVirtualMethod entrypoints used by the bridge; these are identical
// to the macOS AArch64 implementation and therefore are compatible on FreeBSD.

extern "C" void callVirtualFunction(
    sal_uInt64 pFunction, sal_uInt64 pIndirectRet,
    sal_uInt64 *pGPR, double *pFPR,
    unsigned char *pStack, sal_uInt32 nStackBytes,
    sal_uInt64 *pGPRReturn, double *pFPRReturn );

// ... per-bridge wrappers are generated at build time; no further code required here.