;;

    powerpc64)

        CPUNAME=POWERPC64

        RTL_ARCH=PowerPC_64

        PLATFORMID=freebsd_powerpc64

else ifeq ($(OS)-$(CPUNAME),FREEBSD-POWERPC64)

bridges_SELECTED_BRIDGE := gcc3_freebsd_powerpc64

bridge_noopt_objects := cpp2uno uno2cpp

bridge_exception_objects := except

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

 */

#include <com/sun/star/uno/genfunc.hxx>

#include <uno/data.h>

#include <typelib/typedescription.hxx>

#include <osl/endian.h>

#include "bridges/cpp_uno/shared/bridge.hxx"

#include "bridges/cpp_uno/shared/cppinterfaceproxy.hxx"

#include "bridges/cpp_uno/shared/types.hxx"

#include "bridges/cpp_uno/shared/vtablefactory.hxx"

#include "share.hxx"

#include <stdio.h>

#include <string.h>

#ifdef OSL_BIGENDIAN

#define IS_BIG_ENDIAN 1

#else

#define IS_BIG_ENDIAN 0

#endif

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

namespace

{

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_Int64 * pRegisterReturn /* space for register return */ )

{

#if OSL_DEBUG_LEVEL > 2

    fprintf(stderr, "as far as cpp2uno_call\n");

#endif

    int ng = 0; //number of gpr registers used

    int nf = 0; //number of fpr regsiters used

    // gpreg:  [ret *], this, [gpr params]

    // fpreg:  [fpr params]

    // ovrflw: [gpr or fpr params (properly aligned)]

    // return

    typelib_TypeDescription * pReturnTypeDescr = 0;

    if (pReturnTypeRef)

        TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );

    void * pUnoReturn = 0;

    void * pCppReturn = 0; // complex return ptr: if != 0 && != pUnoReturn, reconversion need

    if (pReturnTypeDescr)

    {

        if (!ppc64::return_in_hidden_param(pReturnTypeRef))

        {

            pUnoReturn = pRegisterReturn; // direct way for simple types

        }

        else // complex return via ptr (pCppReturn)

        {

            pCppReturn = *(void **)gpreg;

            gpreg++;

            ng++;

            pUnoReturn = (bridges::cpp_uno::shared::relatesToInterfaceType( pReturnTypeDescr )

                          ? alloca( pReturnTypeDescr->nSize )

                          : pCppReturn); // direct way

        }

    }

    // pop this

    gpreg++;

    ng++;

    // stack space

    OSL_ENSURE( sizeof(void *) == sizeof(sal_Int64), "### unexpected size!" );

    // parameters

    void ** pUnoArgs = (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 = (sal_Int32 *)(pUnoArgs + (2 * nParams));

    // type descriptions for reconversions

    typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));

    sal_Int32 nTempIndices = 0;

    bool bOverflowUsed = false;

    for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )

    {

        const typelib_MethodParameter & rParam = pParams[nPos];

        typelib_TypeDescription * pParamTypeDescr = 0;

        TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );

#if OSL_DEBUG_LEVEL > 2

        fprintf(stderr, "arg %d of %d\n", nPos, nParams);

#endif

        if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))

        {

#if OSL_DEBUG_LEVEL > 2

            fprintf(stderr, "simple\n");

#endif

            switch (pParamTypeDescr->eTypeClass)

            {

                case typelib_TypeClass_FLOAT:

                case typelib_TypeClass_DOUBLE:

                    if (nf < ppc64::MAX_SSE_REGS)

                    {

                        if (pParamTypeDescr->eTypeClass == typelib_TypeClass_FLOAT)

                        {

                            float tmp = (float) (*((double *)fpreg));

                            (*((float *) fpreg)) = tmp;

                        }

                        pCppArgs[nPos] = pUnoArgs[nPos] = fpreg++;

                        nf++;

                    }

                    else

                    {

                        pCppArgs[nPos] = pUnoArgs[nPos] = ovrflw;

                        bOverflowUsed = true;

                    }

                    if (bOverflowUsed) ovrflw++;

                    break;

                case typelib_TypeClass_BYTE:

                case typelib_TypeClass_BOOLEAN:

                    if (ng < ppc64::MAX_GPR_REGS)

                    {

                        pCppArgs[nPos] = pUnoArgs[nPos] = (((char *)gpreg) + 7*IS_BIG_ENDIAN);

                        ng++;

                        gpreg++;

                    }

                    else

                    {

                        pCppArgs[nPos] = pUnoArgs[nPos] = (((char *)ovrflw) + 7*IS_BIG_ENDIAN);

                        bOverflowUsed = true;

                    }

                    if (bOverflowUsed) ovrflw++;

                    break;

                case typelib_TypeClass_CHAR:

                case typelib_TypeClass_SHORT:

                case typelib_TypeClass_UNSIGNED_SHORT:

                    if (ng < ppc64::MAX_GPR_REGS)

                    {

                        pCppArgs[nPos] = pUnoArgs[nPos] = (((char *)gpreg) + 6*IS_BIG_ENDIAN);

                        ng++;

                        gpreg++;

                    }

                    else

                    {

                        pCppArgs[nPos] = pUnoArgs[nPos] = (((char *)ovrflw) + 6*IS_BIG_ENDIAN);

                        bOverflowUsed = true;

                    }

                    if (bOverflowUsed) ovrflw++;

                    break;

        case typelib_TypeClass_ENUM:

                case typelib_TypeClass_LONG:

                case typelib_TypeClass_UNSIGNED_LONG:

                    if (ng < ppc64::MAX_GPR_REGS)

                    {

                        pCppArgs[nPos] = pUnoArgs[nPos] = (((char *)gpreg) + 4*IS_BIG_ENDIAN);

                        ng++;

                        gpreg++;

                    }

                    else

                    {

                        pCppArgs[nPos] = pUnoArgs[nPos] = (((char *)ovrflw) + 4*IS_BIG_ENDIAN);

                        bOverflowUsed = true;

                    }

                    if (bOverflowUsed) ovrflw++;

                    break;

                default:

                    if (ng < ppc64::MAX_GPR_REGS)

                    {

                        pCppArgs[nPos] = pUnoArgs[nPos] = gpreg++;

                        ng++;

                    }

                    else

                    {

                        pCppArgs[nPos] = pUnoArgs[nPos] = ovrflw;

                        bOverflowUsed = true;

                    }

                    if (bOverflowUsed) ovrflw++;

                    break;

                }

                // no longer needed

                TYPELIB_DANGER_RELEASE( pParamTypeDescr );

        }

        else // ptr to complex value | ref

        {

#if OSL_DEBUG_LEVEL > 2

            fprintf(stderr, "complex, ng is %d\n", ng);

#endif

            void *pCppStack; //temporary stack pointer

            if (ng < ppc64::MAX_GPR_REGS)

            {

                pCppArgs[nPos] = pCppStack = *gpreg++;

                ng++;

            }

            else

            {

                pCppArgs[nPos] = pCppStack = *ovrflw;

                bOverflowUsed = true;

            }

            if (bOverflowUsed) 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;

            }

            // is in/inout

            else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))

            {

                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 );

            }

        }

    }

#if OSL_DEBUG_LEVEL > 2

    fprintf(stderr, "end of params\n");

#endif

    // 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], 0 );

            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, 0 );

            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, 0 );

            }

            // complex return ptr is set to return reg

            *(void **)pRegisterReturn = pCppReturn;

        }

        if (pReturnTypeDescr)

        {

            typelib_TypeClass eRet = (typelib_TypeClass)pReturnTypeDescr->eTypeClass;

            TYPELIB_DANGER_RELEASE( pReturnTypeDescr );

            return eRet;

        }

        else

            return typelib_TypeClass_VOID;

    }

}

#if _CALL_ELF == 2

#  define PARAMSAVE 32

#else

#  define PARAMSAVE 48

#endif

static typelib_TypeClass cpp_mediate(

    sal_uInt64 nOffsetAndIndex,

        void ** gpreg, void ** fpreg, long sp,

    sal_Int64 * pRegisterReturn /* space for register return */ )

{

    OSL_ENSURE( sizeof(sal_Int64)==sizeof(void *), "### unexpected!" );

    sal_Int32 nVtableOffset = (nOffsetAndIndex >> 32);

    sal_Int32 nFunctionIndex = (nOffsetAndIndex & 0xFFFFFFFF);

    long sf = *(long*)sp;

    void ** ovrflw = (void**)(sf + PARAMSAVE + 64);

    // 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];

#if OSL_DEBUG_LEVEL > 2

    fprintf(stderr, "pThis is gpreg[1]\n");

#endif

    }

    else

    {

    pThis = gpreg[0];

#if OSL_DEBUG_LEVEL > 2

    fprintf(stderr, "pThis is gpreg[0]\n");

#endif

    }

#if OSL_DEBUG_LEVEL > 2

    fprintf(stderr, "pThis is %lx\n", pThis);

#endif

    pThis = static_cast< char * >(pThis) - nVtableOffset;

#if OSL_DEBUG_LEVEL > 2

    fprintf(stderr, "pThis is now %lx\n", pThis);

#endif

    bridges::cpp_uno::shared::CppInterfaceProxy * pCppI

        = bridges::cpp_uno::shared::CppInterfaceProxy::castInterfaceToProxy(

            pThis);

    typelib_InterfaceTypeDescription * pTypeDescr = pCppI->getTypeDescr();

#if OSL_DEBUG_LEVEL > 2

    fprintf(stderr, "indexes are %d %d\n", nFunctionIndex, pTypeDescr->nMapFunctionIndexToMemberIndex);

#endif

    OSL_ENSURE( nFunctionIndex < pTypeDescr->nMapFunctionIndexToMemberIndex, "### illegal vtable index!" );

    if (nFunctionIndex >= pTypeDescr->nMapFunctionIndexToMemberIndex)

    {

        throw RuntimeException(

            OUString( "illegal vtable index!" ),

            (XInterface *)pThis );

    }

    // determine called method

    sal_Int32 nMemberPos = pTypeDescr->pMapFunctionIndexToMemberIndex[nFunctionIndex];

    OSL_ENSURE( nMemberPos < pTypeDescr->nAllMembers, "### illegal member index!" );

#if OSL_DEBUG_LEVEL > 2

    fprintf(stderr, "members are %d %d\n", nMemberPos, pTypeDescr->nAllMembers);

#endif

    TypeDescription aMemberDescr( pTypeDescr->ppAllMembers[nMemberPos] );

    typelib_TypeClass eRet;

    switch (aMemberDescr.get()->eTypeClass)

    {

    case typelib_TypeClass_INTERFACE_ATTRIBUTE:

    {

        if (pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos] == nFunctionIndex)

        {

            // is GET method

            eRet = cpp2uno_call(

                pCppI, aMemberDescr.get(),

                ((typelib_InterfaceAttributeTypeDescription *)aMemberDescr.get())->pAttributeTypeRef,

                0, 0, // no params

                gpreg, fpreg, ovrflw, pRegisterReturn );

        }

        else

        {

            // is SET method

            typelib_MethodParameter aParam;

            aParam.pTypeRef =

                ((typelib_InterfaceAttributeTypeDescription *)aMemberDescr.get())->pAttributeTypeRef;

            aParam.bIn      = sal_True;

            aParam.bOut     = sal_False;

            eRet = cpp2uno_call(

                pCppI, aMemberDescr.get(),

                0, // 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 = 0;

            TYPELIB_DANGER_GET( &pTD, reinterpret_cast< Type * >( gpreg[2] )->getTypeLibType() );

            if (pTD)

            {

                XInterface * pInterface = 0;

                (*pCppI->getBridge()->getCppEnv()->getRegisteredInterface)(

                    pCppI->getBridge()->getCppEnv(),

                    (void **)&pInterface, pCppI->getOid().pData,

                    (typelib_InterfaceTypeDescription *)pTD );

                if (pInterface)

                {

                    ::uno_any_construct(

                        reinterpret_cast< uno_Any * >( gpreg[0] ),

                        &pInterface, pTD, cpp_acquire );

                    pInterface->release();

                    TYPELIB_DANGER_RELEASE( pTD );

                    *(void **)pRegisterReturn = gpreg[0];

                    eRet = typelib_TypeClass_ANY;

                    break;

                }

                TYPELIB_DANGER_RELEASE( pTD );

            }

        } // else perform queryInterface()

        default:

            eRet = cpp2uno_call(

                pCppI, aMemberDescr.get(),

                ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pReturnTypeRef,

                ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->nParams,

                ((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pParams,

                gpreg, fpreg, ovrflw, pRegisterReturn );

        }

        break;

    }

    default:

    {

#if OSL_DEBUG_LEVEL > 2

        fprintf(stderr, "screwed\n");

#endif

        throw RuntimeException(

            OUString( "no member description found!" ),

            (XInterface *)pThis );

    }

    }

#if OSL_DEBUG_LEVEL > 2

        fprintf(stderr, "end of cpp_mediate\n");

#endif

    return eRet;

}

extern "C" void privateSnippetExecutor( ... )

{

    sal_uInt64 gpreg[ppc64::MAX_GPR_REGS];

    double fpreg[ppc64::MAX_SSE_REGS];

    __asm__ __volatile__ (

        "std 3,   0(%0)\t\n"

        "std 4,   8(%0)\t\n"

        "std 5,  16(%0)\t\n"

        "std 6,  24(%0)\t\n"

        "std 7,  32(%0)\t\n"

        "std 8,  40(%0)\t\n"

        "std 9,  48(%0)\t\n"

        "std 10, 56(%0)\t\n"

        "stfd 1,   0(%1)\t\n"

        "stfd 2,   8(%1)\t\n"

        "stfd 3,  16(%1)\t\n"

        "stfd 4,  24(%1)\t\n"

        "stfd 5,  32(%1)\t\n"

        "stfd 6,  40(%1)\t\n"

        "stfd 7,  48(%1)\t\n"

        "stfd 8,  56(%1)\t\n"

        "stfd 9,  64(%1)\t\n"

        "stfd 10, 72(%1)\t\n"

        "stfd 11, 80(%1)\t\n"

        "stfd 12, 88(%1)\t\n"

        "stfd 13, 96(%1)\t\n"

    : : "r" (gpreg), "r" (fpreg)

        : "r0", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11",

          "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7", "fr8", "fr9",

          "fr10", "fr11", "fr12", "fr13"

    );

    volatile long nOffsetAndIndex;

    //mr %r3, %r11            # move into arg1 the 64bit value passed from OOo

    __asm__ __volatile__ (

                "mr     %0,    11\n\t"

                : "=r" (nOffsetAndIndex) : );

    volatile long sp;

    //stack pointer

    __asm__ __volatile__ (

                "mr     %0,    1\n\t"

                : "=r" (sp) : );

#if _CALL_ELF == 2

    volatile long nRegReturn[2];

#else

    volatile long nRegReturn[1];

#endif

    typelib_TypeClass aType =

        cpp_mediate( nOffsetAndIndex, (void**)gpreg, (void**)fpreg, sp, (sal_Int64*)nRegReturn);

    switch( aType )

    {

        case typelib_TypeClass_VOID:

        break;

        case typelib_TypeClass_BOOLEAN:

        case typelib_TypeClass_BYTE:

            __asm__( "lbz 3,%0\n\t"

                : : "m" (nRegReturn[0]) );

            break;

        case typelib_TypeClass_CHAR:

        case typelib_TypeClass_UNSIGNED_SHORT:

            __asm__( "lhz 3,%0\n\t"

                : : "m" (nRegReturn[0]) );

            break;

        case typelib_TypeClass_SHORT:

            __asm__( "lha 3,%0\n\t"

                : : "m" (nRegReturn[0]) );

            break;

        case typelib_TypeClass_ENUM:

        case typelib_TypeClass_UNSIGNED_LONG:

            __asm__( "lwz 3,%0\n\t"

                : : "m"(nRegReturn[0]) );

            break;

        case typelib_TypeClass_LONG:

            __asm__( "lwa 3,%0\n\t"

                : : "m"(nRegReturn[0]) );

            break;

        case typelib_TypeClass_FLOAT:

            __asm__( "lfs 1,%0\n\t"

                : : "m" (*((float*)nRegReturn)) );

            break;

        case typelib_TypeClass_DOUBLE:

            __asm__( "lfd 1,%0\n\t"

                : : "m" (*((double*)nRegReturn)) );

            break;

        default:

            __asm__( "ld 3,%0\n\t"

                : : "m" (nRegReturn[0]) );

#if _CALL_ELF == 2

            __asm__( "ld 4,%0\n\t"

                : : "m" (nRegReturn[1]) );

#endif

            break;

    }

}

#if _CALL_ELF == 2

const int codeSnippetSize = 32;

#else

const int codeSnippetSize = 24;

#endif

unsigned char *  codeSnippet( unsigned char * code, sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset,

                              bool bHasHiddenParam)

{

#if OSL_DEBUG_LEVEL > 2

    fprintf(stderr,"in codeSnippet functionIndex is %x\n", nFunctionIndex);

    fprintf(stderr,"in codeSnippet vtableOffset is %x\n", nVtableOffset);

#endif

    sal_uInt64 nOffsetAndIndex = ( ( (sal_uInt64) nVtableOffset ) << 32 ) | ( (sal_uInt64) nFunctionIndex );

    if ( bHasHiddenParam )

        nOffsetAndIndex |= 0x80000000;

#if _CALL_ELF == 2

    unsigned int *raw = (unsigned int *)&code[0];

    raw[0] = 0xe96c0018;        /* 0:   ld      11,2f-0b(12)    */

    raw[1] = 0xe98c0010;        /*      ld      12,1f-0b(12)    */

    raw[2] = 0x7d8903a6;        /*      mtctr   12              */

    raw[3] = 0x4e800420;        /*      bctr                    */

                                /* 1:   .quad   function_addr   */

                                /* 2:   .quad   context         */

    *(void **)&raw[4] = (void *)privateSnippetExecutor;

    *(void **)&raw[6] = (void*)nOffsetAndIndex;

#else

    void ** raw = (void **)&code[0];

    memcpy(raw, (char*) privateSnippetExecutor, 16);

    raw[2] = (void*) nOffsetAndIndex;

#endif

#if OSL_DEBUG_LEVEL > 2

    fprintf(stderr, "in: offset/index is %x %x %d, %lx\n",

    nFunctionIndex, nVtableOffset, bHasHiddenParam, raw[2]);

#endif

    return (code + codeSnippetSize);

}

}

void bridges::cpp_uno::shared::VtableFactory::flushCode(unsigned char const * bptr, unsigned char const * eptr)

{

    int const lineSize = 32;

    for (unsigned char const * p = bptr; p < eptr + lineSize; p += lineSize) {

        __asm__ volatile ("dcbst 0, %0" : : "r"(p) : "memory");

    }

    __asm__ volatile ("sync" : : : "memory");

    for (unsigned char const * p = bptr; p < eptr + lineSize; p += lineSize) {

        __asm__ volatile ("icbi 0, %0" : : "r"(p) : "memory");

    }

    __asm__ volatile ("isync" : : : "memory");

}

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;

}

sal_Size 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)

{

    Slot * slots = mapBlockToVtable(block);

    slots[-2].fn = 0;

    slots[-1].fn = 0;

    return slots + slotCount;

}

unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(

    Slot ** slots, unsigned char * code, sal_PtrDiff writetoexecdiff,

    typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,

    sal_Int32 functionCount, sal_Int32 vtableOffset)

{

     (*slots) -= functionCount;

     Slot * s = *slots;

#if OSL_DEBUG_LEVEL > 2

    fprintf(stderr, "in addLocalFunctions functionOffset is %x\n",functionOffset);

    fprintf(stderr, "in addLocalFunctions vtableOffset is %x\n",vtableOffset);

#endif

    for (sal_Int32 i = 0; i < type->nMembers; ++i) {

        typelib_TypeDescription * member = 0;

        TYPELIB_DANGER_GET(&member, type->ppMembers[i]);

        OSL_ASSERT(member != 0);

        switch (member->eTypeClass) {

        case typelib_TypeClass_INTERFACE_ATTRIBUTE:

            // Getter:

            (s++)->fn = code + writetoexecdiff;

            code = codeSnippet(

                code, functionOffset++, vtableOffset,

                ppc64::return_in_hidden_param(

                    reinterpret_cast<

                    typelib_InterfaceAttributeTypeDescription * >(

                        member)->pAttributeTypeRef));

            // Setter:

            if (!reinterpret_cast<

                typelib_InterfaceAttributeTypeDescription * >(

                    member)->bReadOnly)

            {

                (s++)->fn = code + writetoexecdiff;

                code = codeSnippet(code, functionOffset++, vtableOffset, false);

            }

            break;

        case typelib_TypeClass_INTERFACE_METHOD:

            (s++)->fn = code + writetoexecdiff;

            code = codeSnippet(

                code, functionOffset++, vtableOffset,

                ppc64::return_in_hidden_param(

                    reinterpret_cast<

                    typelib_InterfaceMethodTypeDescription * >(

                        member)->pReturnTypeRef));

            break;

        default:

            OSL_ASSERT(false);

            break;

        }

        TYPELIB_DANGER_RELEASE(member);

    }

    return code;

}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

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

 */

#include <stdio.h>

#include <string.h>

#include <dlfcn.h>

#include <cxxabi.h>

#include <boost/unordered_map.hpp>

#include <rtl/strbuf.hxx>

#include <rtl/ustrbuf.hxx>

#include <osl/diagnose.h>

#include <osl/mutex.hxx>

#include <com/sun/star/uno/genfunc.hxx>

#include <typelib/typedescription.hxx>

#include <uno/any2.h>

#include "share.hxx"

using namespace ::std;

using namespace ::osl;

using namespace ::rtl;

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

using namespace ::__cxxabiv1;

namespace CPPU_CURRENT_NAMESPACE

{

void dummy_can_throw_anything( char const * )

{

}

static OUString toUNOname( char const * p ) SAL_THROW(())

{

#if OSL_DEBUG_LEVEL > 1

    char const * start = p;

#endif

    // example: N3com3sun4star4lang24IllegalArgumentExceptionE

    OUStringBuffer buf( 64 );

    OSL_ASSERT( 'N' == *p );

    ++p; // skip N

    while ('E' != *p)

    {

        // read chars count

        long n = (*p++ - '0');

        while ('0' <= *p && '9' >= *p)

        {

            n *= 10;

            n += (*p++ - '0');

        }

        buf.appendAscii( p, n );

        p += n;

        if ('E' != *p)

            buf.append( '.' );

    }

#if OSL_DEBUG_LEVEL > 1

    OUString ret( buf.makeStringAndClear() );

    OString c_ret( OUStringToOString( ret, RTL_TEXTENCODING_ASCII_US ) );

    fprintf( stderr, "> toUNOname(): %s => %s\n", start, c_ret.getStr() );

    return ret;

#else

    return buf.makeStringAndClear();

#endif

}

class RTTI

{

    typedef boost::unordered_map< OUString, type_info *, OUStringHash > t_rtti_map;

    Mutex m_mutex;

    t_rtti_map m_rttis;

    t_rtti_map m_generatedRttis;

    void * m_hApp;

public:

    RTTI() SAL_THROW(());

    ~RTTI() SAL_THROW(());

    type_info * getRTTI( typelib_CompoundTypeDescription * ) SAL_THROW(());

};

RTTI::RTTI() SAL_THROW(())

    : m_hApp( dlopen( 0, RTLD_LAZY ) )

{

}

RTTI::~RTTI() SAL_THROW(())

{

    dlclose( m_hApp );

}

type_info * RTTI::getRTTI( typelib_CompoundTypeDescription *pTypeDescr ) SAL_THROW(())

{

    type_info * rtti;

    OUString const & unoName = *(OUString const *)&pTypeDescr->aBase.pTypeName;

    MutexGuard guard( m_mutex );

    t_rtti_map::const_iterator iRttiFind( m_rttis.find( unoName ) );

    if (iRttiFind == m_rttis.end())

    {

        // RTTI symbol

        OStringBuffer buf( 64 );

        buf.append( "_ZTIN" );

        sal_Int32 index = 0;

        do

        {

            OUString token( unoName.getToken( 0, '.', index ) );

            buf.append( token.getLength() );

            OString c_token( OUStringToOString( token, RTL_TEXTENCODING_ASCII_US ) );

            buf.append( c_token );

        }

        while (index >= 0);

        buf.append( 'E' );

        OString symName( buf.makeStringAndClear() );

        rtti = (type_info *)dlsym( m_hApp, symName.getStr() );

        if (rtti)

        {

            pair< t_rtti_map::iterator, bool > insertion(

                m_rttis.insert( t_rtti_map::value_type( unoName, rtti ) ) );

            OSL_ENSURE( insertion.second, "### inserting new rtti failed?!" );

        }

        else

        {

            // try to lookup the symbol in the generated rtti map

            t_rtti_map::const_iterator iFind( m_generatedRttis.find( unoName ) );

            if (iFind == m_generatedRttis.end())

            {

                // we must generate it !

                // symbol and rtti-name is nearly identical,

                // the symbol is prefixed with _ZTI

                char const * rttiName = symName.getStr() +4;

#if OSL_DEBUG_LEVEL > 1

                fprintf( stderr,"generated rtti for %s\n", rttiName );

#endif

                if (pTypeDescr->pBaseTypeDescription)

                {

                    // ensure availability of base

                    type_info * base_rtti = getRTTI(

                        (typelib_CompoundTypeDescription *)pTypeDescr->pBaseTypeDescription );

                    rtti = new __si_class_type_info(

                        strdup( rttiName ), (__class_type_info *)base_rtti );

                }

                else

                {

                    // this class has no base class

                    rtti = new __class_type_info( strdup( rttiName ) );

                }

                pair< t_rtti_map::iterator, bool > insertion(

                    m_generatedRttis.insert( t_rtti_map::value_type( unoName, rtti ) ) );

                OSL_ENSURE( insertion.second, "### inserting new generated rtti failed?!" );

            }

            else // taking already generated rtti

            {

                rtti = iFind->second;

            }

        }

    }

    else

    {

        rtti = iRttiFind->second;

    }

    return rtti;

}

static void deleteException( void * pExc )

{

    __cxa_exception const * header = ((__cxa_exception const *)pExc - 1);

    typelib_TypeDescription * pTD = 0;

    OUString unoName( toUNOname( header->exceptionType->name() ) );

    ::typelib_typedescription_getByName( &pTD, unoName.pData );

    OSL_ENSURE( pTD, "### unknown exception type! leaving out destruction => leaking!!!" );

    if (pTD)

    {

        ::uno_destructData( pExc, pTD, cpp_release );

        ::typelib_typedescription_release( pTD );

    }

}

void raiseException( uno_Any * pUnoExc, uno_Mapping * pUno2Cpp )

{

    void * pCppExc;

    type_info * rtti;

    {

    // construct cpp exception object

    typelib_TypeDescription * pTypeDescr = 0;

    TYPELIB_DANGER_GET( &pTypeDescr, pUnoExc->pType );

    OSL_ASSERT( pTypeDescr );

    if (! pTypeDescr)

        terminate();

    pCppExc = __cxa_allocate_exception( pTypeDescr->nSize );

    ::uno_copyAndConvertData( pCppExc, pUnoExc->pData, pTypeDescr, pUno2Cpp );

    // destruct uno exception

    ::uno_any_destruct( pUnoExc, 0 );

    // avoiding locked counts

    static RTTI * s_rtti = 0;

    if (! s_rtti)

    {

        MutexGuard guard( Mutex::getGlobalMutex() );

        if (! s_rtti)

        {

#ifdef LEAK_STATIC_DATA

            s_rtti = new RTTI();

#else

            static RTTI rtti_data;

            s_rtti = &rtti_data;

#endif

        }

    }

    rtti = (type_info *)s_rtti->getRTTI( (typelib_CompoundTypeDescription *) pTypeDescr );

    TYPELIB_DANGER_RELEASE( pTypeDescr );

    OSL_ENSURE( rtti, "### no rtti for throwing exception!" );

    if (! rtti)

        terminate();

    }

    __cxa_throw( pCppExc, rtti, deleteException );

}

void fillUnoException( __cxa_exception * header, uno_Any * pExc, uno_Mapping * pCpp2Uno )

{

    OSL_ENSURE( header, "### no exception header!!!" );

    if (! header)

        terminate();

    typelib_TypeDescription * pExcTypeDescr = 0;

    OUString unoName( toUNOname( header->exceptionType->name() ) );

    ::typelib_typedescription_getByName( &pExcTypeDescr, unoName.pData );

    OSL_ENSURE( pExcTypeDescr, "### can not get type description for exception!!!" );

    if (! pExcTypeDescr)

        terminate();

    // construct uno exception any

    ::uno_any_constructAndConvert( pExc, header->adjustedPtr, pExcTypeDescr, pCpp2Uno );

    ::typelib_typedescription_release( pExcTypeDescr );

}

}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

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

#define INCLUDED_BRIDGES_SOURCE_CPP_UNO_GCC3_FREEBSD_POWERPC64_SHARE_HXX

#include "uno/mapping.h"

#include <typeinfo>

#include <exception>

#include <cstddef>

namespace CPPU_CURRENT_NAMESPACE

{

  void dummy_can_throw_anything( char const * );

// ----- following decl from libstdc++-v3/libsupc++/unwind-cxx.h and unwind.h

struct _Unwind_Exception

{

    unsigned exception_class __attribute__((__mode__(__DI__)));

    void * exception_cleanup;

    unsigned private_1 __attribute__((__mode__(__word__)));

    unsigned private_2 __attribute__((__mode__(__word__)));

} __attribute__((__aligned__));

struct __cxa_exception

{

    ::std::type_info *exceptionType;

    void (*exceptionDestructor)(void *);

    ::std::unexpected_handler unexpectedHandler;

    ::std::terminate_handler terminateHandler;

    __cxa_exception *nextException;

    int handlerCount;

    int handlerSwitchValue;

    const unsigned char *actionRecord;

    const unsigned char *languageSpecificData;

    void *catchTemp;

    void *adjustedPtr;

    _Unwind_Exception unwindHeader;

};

extern "C" void *__cxa_allocate_exception(

    std::size_t thrown_size ) throw();

extern "C" void __cxa_throw (

    void *thrown_exception, std::type_info *tinfo, void (*dest) (void *) ) __attribute__((noreturn));

struct __cxa_eh_globals

{

    __cxa_exception *caughtExceptions;

    unsigned int uncaughtExceptions;

};

extern "C" __cxa_eh_globals *__cxa_get_globals () throw();

void raiseException(

    uno_Any * pUnoExc, uno_Mapping * pUno2Cpp );

void fillUnoException(

    __cxa_exception * header, uno_Any *, uno_Mapping * pCpp2Uno );

}

namespace ppc64

{

    enum ppclimits { MAX_GPR_REGS = 8, MAX_SSE_REGS = 13 };

    bool return_in_hidden_param( typelib_TypeDescriptionReference *pTypeRef );

}

#endif

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

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

 */

#include <stdlib.h>

#include <com/sun/star/uno/genfunc.hxx>

#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 "share.hxx"

#include <stdio.h>

#include <string.h>

using namespace ::rtl;

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

namespace ppc64

{

#if _CALL_ELF == 2

    bool is_complex_struct(const typelib_TypeDescription * type)

    {

        const typelib_CompoundTypeDescription * p

            = reinterpret_cast< const typelib_CompoundTypeDescription * >(type);

        for (sal_Int32 i = 0; i < p->nMembers; ++i)

        {

            if (p->ppTypeRefs[i]->eTypeClass == typelib_TypeClass_STRUCT ||

                p->ppTypeRefs[i]->eTypeClass == typelib_TypeClass_EXCEPTION)

            {

                typelib_TypeDescription * t = 0;

                TYPELIB_DANGER_GET(&t, p->ppTypeRefs[i]);

                bool b = is_complex_struct(t);

                TYPELIB_DANGER_RELEASE(t);

                if (b) {

                    return true;

                }

            }

            else if (!bridges::cpp_uno::shared::isSimpleType(p->ppTypeRefs[i]->eTypeClass))

                return true;

        }

        if (p->pBaseTypeDescription != 0)

            return is_complex_struct(&p->pBaseTypeDescription->aBase);

        return false;

    }

#endif

    bool return_in_hidden_param( typelib_TypeDescriptionReference *pTypeRef )

    {

        if (bridges::cpp_uno::shared::isSimpleType(pTypeRef))

            return false;

#if _CALL_ELF == 2

        else if (pTypeRef->eTypeClass == typelib_TypeClass_STRUCT || pTypeRef->eTypeClass == typelib_TypeClass_EXCEPTION)

        {

            typelib_TypeDescription * pTypeDescr = 0;

            TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef );

            //A Composite Type not larger than 16 bytes is returned in up to two GPRs

            bool bRet = pTypeDescr->nSize > 16 || is_complex_struct(pTypeDescr);

            TYPELIB_DANGER_RELEASE( pTypeDescr );

            return bRet;

        }

#endif

        return true;

    }

}

void MapReturn(long r3, long r4, double dret, typelib_TypeDescriptionReference* pReturnType, void *pRegisterReturn)

{

    switch (pReturnType->eTypeClass)

    {

    case typelib_TypeClass_HYPER:

    case typelib_TypeClass_UNSIGNED_HYPER:

            *reinterpret_cast<sal_uInt64 *>( pRegisterReturn ) = r3;

            break;

    case typelib_TypeClass_LONG:

    case typelib_TypeClass_UNSIGNED_LONG:

    case typelib_TypeClass_ENUM:

            *reinterpret_cast<sal_uInt32 *>( pRegisterReturn ) = r3;

            break;

    case typelib_TypeClass_CHAR:

    case typelib_TypeClass_SHORT:

    case typelib_TypeClass_UNSIGNED_SHORT:

            *reinterpret_cast<sal_uInt16 *>( pRegisterReturn ) = (unsigned short)r3;

            break;

    case typelib_TypeClass_BOOLEAN:

    case typelib_TypeClass_BYTE:

            *reinterpret_cast<sal_uInt8 *>( pRegisterReturn ) = (unsigned char)r3;

            break;

    case typelib_TypeClass_FLOAT:

            *reinterpret_cast<float *>( pRegisterReturn ) = dret;

        break;

    case typelib_TypeClass_DOUBLE:

            *reinterpret_cast<double *>( pRegisterReturn ) = dret;

            break;

#if _CALL_ELF == 2

    case typelib_TypeClass_STRUCT:

    case typelib_TypeClass_EXCEPTION:

            if (!ppc64::return_in_hidden_param(pReturnType))

            {

                sal_uInt64 *pRegisters = reinterpret_cast<sal_uInt64*>(pRegisterReturn);

                pRegisters[0] = r3;

                if (pReturnType->pType->nSize > 8)

                    pRegisters[1] = r4;

            }

#endif

    default:

            break;

    }

}

namespace

{

static void callVirtualMethod(void * pThis, sal_uInt32 nVtableIndex,

    void * pRegisterReturn, typelib_TypeDescription * pReturnTypeDescr,

        sal_uInt64 *pStack, sal_uInt32 nStack,

        sal_uInt64 *pGPR, sal_uInt32 nGPR,

        double *pFPR, sal_uInt32 nFPR)

{

    // Stack, if used, must be 16-bytes aligned

    if ( nStack )

        nStack = ( nStack + 1 ) & ~1;

    // Should not happen, but...

    if ( nFPR > ppc64::MAX_SSE_REGS )

        nFPR = ppc64::MAX_SSE_REGS;

    if ( nGPR > ppc64::MAX_GPR_REGS )

        nGPR = ppc64::MAX_GPR_REGS;

#if OSL_DEBUG_LEVEL > 2

        // Let's figure out what is really going on here

        {

                fprintf( stderr, "= callVirtualMethod() =\nGPR's (%d): ", nGPR );

                for ( int i = 0; i < nGPR; ++i )

                        fprintf( stderr, "0x%lx, ", pGPR[i] );

                fprintf( stderr, "\nFPR's (%d): ", nFPR );

                for ( int i = 0; i < nFPR; ++i )

                        fprintf( stderr, "0x%lx (%f), ", pFPR[i], pFPR[i] );

                fprintf( stderr, "\nStack (%d): ", nStack );

                for ( int i = 0; i < nStack; ++i )

                        fprintf( stderr, "0x%lx, ", pStack[i] );

                fprintf( stderr, "\n" );

        }

#endif

    // Load parameters to stack, if necessary

    sal_uInt64 *stack = (sal_uInt64 *) __builtin_alloca( nStack * 8 );

    memcpy( stack, pStack, nStack * 8 );

    // Get pointer to method

    sal_uInt64 pMethod = *((sal_uInt64 *)pThis);

    pMethod += 8 * nVtableIndex;

    pMethod = *((sal_uInt64 *)pMethod);

#if _CALL_ELF == 2

    typedef void (* FunctionCall )(...);

#else

    typedef void (* FunctionCall )( sal_uInt64, sal_uInt64, sal_uInt64, sal_uInt64, sal_uInt64, sal_uInt64, sal_uInt64, sal_uInt64 );

#endif

    FunctionCall pFunc = (FunctionCall)pMethod;

    volatile double dret;

    //  fill registers

    __asm__ __volatile__ (

                "ld   3,  0(%0)\n\t"

                "ld   4,  8(%0)\n\t"

                "ld   5, 16(%0)\n\t"

                "ld   6, 24(%0)\n\t"

                "ld   7, 32(%0)\n\t"

                "ld   8, 40(%0)\n\t"

                "ld   9, 48(%0)\n\t"

                "ld  10, 56(%0)\n\t"

                "lfd  1,  0(%1)\n\t"

                "lfd  2,  8(%1)\n\t"

                "lfd  3, 16(%1)\n\t"

                "lfd  4, 24(%1)\n\t"

                "lfd  5, 32(%1)\n\t"

                "lfd  6, 40(%1)\n\t"

                "lfd  7, 48(%1)\n\t"

                "lfd  8, 56(%1)\n\t"

                "lfd  9, 64(%1)\n\t"

                "lfd 10, 72(%1)\n\t"

                "lfd 11, 80(%1)\n\t"

                "lfd 12, 88(%1)\n\t"

                "lfd 13, 96(%1)\n\t"

                : : "r" (pGPR), "r" (pFPR)

              : "r0", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10",

                  "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7", "fr8", "fr9",

                  "fr10", "fr11", "fr12", "fr13"

    );

    // tell gcc that r3 to r11 are not available to it for doing the TOC and exception munge on the func call

    register sal_uInt64 r3 asm("r3");

    register sal_uInt64 r4 asm("r4");

    register sal_uInt64 r5 asm("r5");

    register sal_uInt64 r6 asm("r6");

    register sal_uInt64 r7 asm("r7");

    register sal_uInt64 r8 asm("r8");

    register sal_uInt64 r9 asm("r9");

    register sal_uInt64 r10 asm("r10");

    register sal_uInt64 r11 asm("r11");

    (*pFunc)(r3, r4, r5, r6, r7, r8, r9, r10);

    // get return value

    __asm__ __volatile__ (

                "mr     %1,     3\n\t"

                "mr     %2,     4\n\t"

                "fmr    %0,     1\n\t"

                : "=f" (dret), "=r" (r3), "=r" (r4) : );

    MapReturn(r3, r4, dret, reinterpret_cast<typelib_TypeDescriptionReference *>(pReturnTypeDescr), pRegisterReturn);

}

// Macros 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

#define INSERT_FLOAT( pSV, nr, pFPR, pDS, bOverflow ) \

        if ( nr < ppc64::MAX_SSE_REGS ) \

                pFPR[nr++] = *reinterpret_cast<float *>( pSV ); \

        else \

            bOverflow = true; \

        if (bOverflow) \

                *pDS++ = *reinterpret_cast<sal_uInt64 *>( pSV ); // verbatim!

#define INSERT_DOUBLE( pSV, nr, pFPR, pDS, bOverflow ) \

        if ( nr < ppc64::MAX_SSE_REGS ) \

                pFPR[nr++] = *reinterpret_cast<double *>( pSV ); \

        else \

            bOverflow = true; \

        if (bOverflow) \

                *pDS++ = *reinterpret_cast<sal_uInt64 *>( pSV ); // verbatim!

#define INSERT_INT64( pSV, nr, pGPR, pDS, bOverflow ) \

        if ( nr < ppc64::MAX_GPR_REGS ) \

                pGPR[nr++] = *reinterpret_cast<sal_uInt64 *>( pSV ); \

        else \

        bOverflow = true; \

    if (bOverflow) \

                *pDS++ = *reinterpret_cast<sal_uInt64 *>( pSV );

#define INSERT_INT32( pSV, nr, pGPR, pDS, bOverflow ) \

        if ( nr < ppc64::MAX_GPR_REGS ) \

                pGPR[nr++] = *reinterpret_cast<sal_uInt32 *>( pSV ); \

        else \

                bOverflow = true; \

        if (bOverflow) \

                *pDS++ = *reinterpret_cast<sal_uInt32 *>( pSV );

#define INSERT_INT16( pSV, nr, pGPR, pDS, bOverflow ) \

        if ( nr < ppc64::MAX_GPR_REGS ) \

                pGPR[nr++] = *reinterpret_cast<sal_uInt16 *>( pSV ); \

        else \

                bOverflow = true; \

        if (bOverflow) \

                *pDS++ = *reinterpret_cast<sal_uInt16 *>( pSV );

#define INSERT_INT8( pSV, nr, pGPR, pDS, bOverflow ) \

        if ( nr < ppc64::MAX_GPR_REGS ) \

                pGPR[nr++] = *reinterpret_cast<sal_uInt8 *>( pSV ); \

        else \

                bOverflow = true; \

        if (bOverflow) \

                *pDS++ = *reinterpret_cast<sal_uInt8 *>( 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 )

{

      // max space for: [complex ret ptr], values|ptr ...

      sal_uInt64 * pStack = (sal_uInt64 *)alloca( (nParams+3) * sizeof(sal_Int64) );

      sal_uInt64 * pStackStart = pStack;

    sal_uInt64 pGPR[ppc64::MAX_GPR_REGS];

    sal_uInt32 nGPR = 0;

    double pFPR[ppc64::MAX_SSE_REGS];

    sal_uInt32 nFPR = 0;

    // return

    typelib_TypeDescription * pReturnTypeDescr = 0;

    TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );

    OSL_ENSURE( pReturnTypeDescr, "### expected return type description!" );

    void * pCppReturn = 0; // if != 0 && != pUnoReturn, needs reconversion

    bool bOverflow = false;

    bool bSimpleReturn = true;

    if (pReturnTypeDescr)

    {

#if OSL_DEBUG_LEVEL > 2

        fprintf(stderr, "return type is %d\n", pReturnTypeDescr->eTypeClass);

#endif

        if (ppc64::return_in_hidden_param(pReturnTypeRef))

            bSimpleReturn = false;

        if (bSimpleReturn)

        {

            pCppReturn = pUnoReturn; // direct way for simple types

#if OSL_DEBUG_LEVEL > 2

            fprintf(stderr, "simple return\n");

#endif

        }

        else

        {

            // complex return via ptr

            pCppReturn = (bridges::cpp_uno::shared::relatesToInterfaceType( pReturnTypeDescr )

                   ? alloca( pReturnTypeDescr->nSize ) : pUnoReturn);

#if OSL_DEBUG_LEVEL > 2

            fprintf(stderr, "pCppReturn/pUnoReturn is %lx/%lx", pCppReturn, pUnoReturn);

#endif

            INSERT_INT64( &pCppReturn, nGPR, pGPR, pStack, bOverflow );

        }

    }

    // push "this" pointer

        void * pAdjustedThisPtr = reinterpret_cast< void ** >( pThis->getCppI() ) + aVtableSlot.offset;

#if OSL_DEBUG_LEVEL > 2

    fprintf(stderr, "this pointer is %p\n", pAdjustedThisPtr);

#endif

    INSERT_INT64( &pAdjustedThisPtr, nGPR, pGPR, pStack, bOverflow );

        // Args

        void ** pCppArgs = (void **)alloca( 3 * sizeof(void *) * nParams );

    // indices of values this have to be converted (interface conversion cpp<=>uno)

    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);

    // type descriptions for reconversions

    typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));

    sal_Int32 nTempIndices   = 0;

#if OSL_DEBUG_LEVEL > 2

    fprintf(stderr, "n params is %d\n", nParams);

#endif

    for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )

    {

        const typelib_MethodParameter & rParam = pParams[nPos];

        typelib_TypeDescription * pParamTypeDescr = 0;

        TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );

#if OSL_DEBUG_LEVEL > 2

        fprintf(stderr, "param %d is %d %d %d\n", nPos, rParam.bOut, bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ),

            pParamTypeDescr->eTypeClass);

#endif

        if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))

        {

//          uno_copyAndConvertData( pCppArgs[nPos] = alloca( 8 ), pUnoArgs[nPos], pParamTypeDescr,

            uno_copyAndConvertData( pCppArgs[nPos] = pStack, pUnoArgs[nPos], pParamTypeDescr,

                                    pThis->getBridge()->getUno2Cpp() );

                switch (pParamTypeDescr->eTypeClass)

                        {

                        case typelib_TypeClass_HYPER:

                        case typelib_TypeClass_UNSIGNED_HYPER:

#if OSL_DEBUG_LEVEL > 2

                fprintf(stderr, "hyper is %lx\n", pCppArgs[nPos]);

#endif

                                INSERT_INT64( pCppArgs[nPos], nGPR, pGPR, pStack, bOverflow );

                                break;

                        case typelib_TypeClass_LONG:

                        case typelib_TypeClass_UNSIGNED_LONG:

                        case typelib_TypeClass_ENUM:

#if OSL_DEBUG_LEVEL > 2

                fprintf(stderr, "long is %x\n", pCppArgs[nPos]);

#endif

                                INSERT_INT32( pCppArgs[nPos], nGPR, pGPR, pStack, bOverflow );

                                break;

                        case typelib_TypeClass_SHORT:

                        case typelib_TypeClass_CHAR:

                        case typelib_TypeClass_UNSIGNED_SHORT:

                                INSERT_INT16( pCppArgs[nPos], nGPR, pGPR, pStack, bOverflow );

                                break;

                        case typelib_TypeClass_BOOLEAN:

                        case typelib_TypeClass_BYTE:

                                INSERT_INT8( pCppArgs[nPos], nGPR, pGPR, pStack, bOverflow );

                                break;

                        case typelib_TypeClass_FLOAT:

                                INSERT_FLOAT( pCppArgs[nPos], nFPR, pFPR, pStack, bOverflow );

                break;

                        case typelib_TypeClass_DOUBLE:

                                INSERT_DOUBLE( pCppArgs[nPos], nFPR, pFPR, pStack, bOverflow );

                                break;

                        }

                        // no longer needed

                        TYPELIB_DANGER_RELEASE( pParamTypeDescr );

        }

        else // ptr to complex value | ref

        {

#if OSL_DEBUG_LEVEL > 2

            fprintf(stderr, "complex type again %d\n", rParam.bIn);

#endif

                        if (! rParam.bIn) // is pure out

                        {

#if OSL_DEBUG_LEVEL > 2

                fprintf(stderr, "complex size is %d\n", pParamTypeDescr->nSize );

#endif

                                // 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 ))

                        {

#if OSL_DEBUG_LEVEL > 2

                fprintf(stderr, "this one\n");

#endif

                                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

                        {

#if OSL_DEBUG_LEVEL > 2

                fprintf(stderr, "that one, passing %lx through\n", pUnoArgs[nPos]);

#endif

                                pCppArgs[nPos] = pUnoArgs[nPos];

                                // no longer needed

                                TYPELIB_DANGER_RELEASE( pParamTypeDescr );

                        }

                        INSERT_INT64( &(pCppArgs[nPos]), nGPR, pGPR, pStack, bOverflow );

        }

    }

    try

    {

               callVirtualMethod(

                        pAdjustedThisPtr, aVtableSlot.index,

                        pCppReturn, pReturnTypeDescr,

                        pStackStart, ( pStack - pStackStart ),

                        pGPR, nGPR,

                        pFPR, nFPR );

        // NO exception occurred...

        *ppUnoExc = 0;

        // 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, 0 ); // 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

        fillUnoException( CPPU_CURRENT_NAMESPACE::__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);

    switch (pMemberDescr->eTypeClass)

    {

    case typelib_TypeClass_INTERFACE_ATTRIBUTE:

    {

        VtableSlot aVtableSlot(

            getVtableSlot(

                reinterpret_cast<

                    typelib_InterfaceAttributeTypeDescription const * >(

                        pMemberDescr)));

        if (pReturn)

        {

            // dependent dispatch

            cpp_call(

                pThis, aVtableSlot,

                ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef,

                0, 0, // no params

                pReturn, pArgs, ppException );

        }

        else

        {

            // is SET

            typelib_MethodParameter aParam;

            aParam.pTypeRef =

                ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef;

            aParam.bIn      = sal_True;

            aParam.bOut     = sal_False;

            typelib_TypeDescriptionReference * pReturnTypeRef = 0;

            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,

                pReturnTypeRef,

                1, &aParam,

                pReturn, pArgs, ppException );

            typelib_typedescriptionreference_release( pReturnTypeRef );

        }

        break;

    }

    case typelib_TypeClass_INTERFACE_METHOD:

    {

        VtableSlot aVtableSlot(

            getVtableSlot(

                reinterpret_cast<

                    typelib_InterfaceMethodTypeDescription const * >(

                        pMemberDescr)));

        switch (aVtableSlot.index)

        {

            // standard calls

        case 1: // acquire uno interface

            (*pUnoI->acquire)( pUnoI );

            *ppException = 0;

            break;

        case 2: // release uno interface

            (*pUnoI->release)( pUnoI );

            *ppException = 0;

            break;

        case 0: // queryInterface() opt

        {

            typelib_TypeDescription * pTD = 0;

            TYPELIB_DANGER_GET( &pTD, reinterpret_cast< Type * >( pArgs[0] )->getTypeLibType() );

            if (pTD)

            {

                uno_Interface * pInterface = 0;

                (*pThis->pBridge->getUnoEnv()->getRegisteredInterface)(

                    pThis->pBridge->getUnoEnv(),

                    (void **)&pInterface, pThis->oid.pData, (typelib_InterfaceTypeDescription *)pTD );

                if (pInterface)

                {

                    ::uno_any_construct(

                        reinterpret_cast< uno_Any * >( pReturn ),

                        &pInterface, pTD, 0 );

                    (*pInterface->release)( pInterface );

                    TYPELIB_DANGER_RELEASE( pTD );

                    *ppException = 0;

                    break;

                }

                TYPELIB_DANGER_RELEASE( pTD );

            }

        } // else perform queryInterface()

        default:

            // dependent dispatch

            cpp_call(

                pThis, aVtableSlot,

                ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pReturnTypeRef,

                ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->nParams,

                ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pParams,

                pReturn, pArgs, ppException );

        }

        break;

    }

    default:

    {

        ::com::sun::star::uno::RuntimeException aExc(

            OUString("illegal member type description!"),

            ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >() );

        Type const & rExcType = ::getCppuType( &aExc );

        // binary identical null reference

        ::uno_type_any_construct( *ppException, &aExc, rExcType.getTypeLibType(), 0 );

    }

    }

}

} } }

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-

#

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

#

#please make generic modifications to unxgcc.mk or linux.mk

gb_CPUDEFS += -DPPC -DPOWERPC64

gb_COMPILERDEFAULTOPTFLAGS := -O2

gb_CXXFLAGS += -mminimal-toc

include $(GBUILDDIR)/platform/unxgcc.mk

# vim: set noet sw=4:

#include <osl/endian.h>

#include <osl/endian.h>

#include <osl/endian.h>

#define PLATFORM_FREEBSD_POWERPC64  "freebsd_powerpc64"

        else if (token == PLATFORM_FREEBSD_POWERPC64)

            ret = checkOSandCPU("FreeBSD", "POWERPC64");

#include <osl/endian.h>