Attachment 177718 Details for Bug 200020 – Patches to provide full powerpc64 support and fix menu and toolbar issues.

[patch] Patches to provide full powerpc64 support and fix menu and toolbar issues.

patch-libreoffice4_powerpc64 (text/plain), 70.58 KB, created by Curtis Hamilton on 2016-12-06 13:20:02 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Curtis Hamilton

Created: 2016-12-06 13:20:02 UTC

Size: 70.58 KB

patch

obsolete

>--- configure.ac.orig
>+++ configure.ac
>@@ -4189,6 +4189,11 @@
>         CPUNAME=X86_64
>         RTL_ARCH=X86_64
>         PLATFORMID=freebsd_x86_64
>+        ;;
>+    powerpc64)
>+        CPUNAME=POWERPC64
>+        RTL_ARCH=PowerPC_64
>+        PLATFORMID=freebsd_powerpc64
>         ;;
>     *)
>         AC_MSG_ERROR([Unsupported host_cpu $host_cpu for host_os $host_os])
>--- bridges/Library_cpp_uno.mk.orig
>+++ bridges/Library_cpp_uno.mk
>@@ -118,6 +118,12 @@
> bridge_asm_objects := call
> bridge_noopt_objects := except
> bridge_exception_objects := cpp2uno uno2cpp
>+
>+else ifeq ($(OS)-$(CPUNAME),FREEBSD-POWERPC64)
>+
>+bridges_SELECTED_BRIDGE := gcc3_freebsd_powerpc64
>+bridge_noopt_objects := cpp2uno uno2cpp
>+bridge_exception_objects := except
> 
> else ifeq ($(CPUNAME),X86_64)
> 
>--- /dev/null
>+++ bridges/source/cpp_uno/gcc3_freebsd_powerpc64/cpp2uno.cxx
>@@ -0,0 +1,743 @@
>+/* -*- 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: */
>--- /dev/null
>+++ bridges/source/cpp_uno/gcc3_freebsd_powerpc64/except.cxx
>@@ -0,0 +1,274 @@
>+/* -*- 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: */
>--- /dev/null
>+++ bridges/source/cpp_uno/gcc3_freebsd_powerpc64/share.hxx
>@@ -0,0 +1,92 @@
>+/* -*- 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: */
>--- /dev/null
>+++ bridges/source/cpp_uno/gcc3_freebsd_powerpc64/uno2cpp.cxx
>@@ -0,0 +1,659 @@
>+/* -*- 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: */
>--- /dev/null
>+++ solenv/gbuild/platform/FREEBSD_POWERPC64_GCC.mk
>@@ -0,0 +1,17 @@
>+# -*- 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:
>--- canvas/source/cairo/cairo_canvashelper.cxx.orig
>+++ canvas/source/cairo/cairo_canvashelper.cxx
>@@ -17,6 +17,7 @@
>  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
>  */
> 
>+#include <osl/endian.h>
> #include <canvas/debug.hxx>
> #include <tools/diagnose_ex.h>
> 
>--- canvas/source/tools/canvastools.cxx.orig
>+++ canvas/source/tools/canvastools.cxx
>@@ -58,6 +58,8 @@
> #include <vcl/window.hxx>
> #include <vcl/canvastools.hxx>
> 
>+#include <osl/endian.h>
>+
> #include <canvas/canvastools.hxx>
> 
> #include <limits>
>--- connectivity/source/drivers/odbc/OTools.cxx.orig
>+++ connectivity/source/drivers/odbc/OTools.cxx
>@@ -26,7 +26,7 @@
> #include <rtl/ustrbuf.hxx>
> #include <boost/static_assert.hpp>
> 
>-
>+#include <osl/endian.h>
> #include <string.h>
> #include <string>
> #include <algorithm>
>--- cppcanvas/source/inc/implrenderer.hxx.orig
>+++ cppcanvas/source/inc/implrenderer.hxx
>@@ -30,6 +30,8 @@
> #include <action.hxx>
> #include <outdevstate.hxx>
> 
>+#include <osl/endian.h>
>+
> #include <vector>
> #include <map>
> 
>--- desktop/source/deployment/misc/dp_platform.cxx.orig
>+++ desktop/source/deployment/misc/dp_platform.cxx
>@@ -52,6 +52,7 @@
> #define PLATFORM_SOLARIS_SPARC      "solaris_sparc"
> #define PLATFORM_SOLARIS_SPARC64    "solaris_sparc64"
> #define PLATFORM_SOLARIS_X86        "solaris_x86"
>+#define PLATFORM_FREEBSD_POWERPC64  "freebsd_powerpc64"
> #define PLATFORM_FREEBSD_X86        "freebsd_x86"
> #define PLATFORM_FREEBSD_X86_64     "freebsd_x86_64"
> #define PLATFORM_NETBSD_X86         "netbsd_x86"
>@@ -158,6 +159,8 @@
>             ret = checkOSandCPU("Solaris", "SPARC64");
>         else if (token == PLATFORM_SOLARIS_X86)
>             ret = checkOSandCPU("Solaris", "x86");
>+        else if (token == PLATFORM_FREEBSD_POWERPC64)
>+            ret = checkOSandCPU("FreeBSD", "POWERPC64");
>         else if (token == PLATFORM_FREEBSD_X86)
>             ret = checkOSandCPU("FreeBSD", "x86");
>         else if (token == PLATFORM_FREEBSD_X86_64)
>--- include/basebmp/rgbmaskpixelformats.hxx.orig
>+++ include/basebmp/rgbmaskpixelformats.hxx
>@@ -31,6 +31,8 @@
> #include <vigra/numerictraits.hxx>
> #include <vigra/metaprogramming.hxx>
> 
>+#include <osl/endian.h>
>+
> #include <functional>
> 
> namespace basebmp
>--- include/osl/endian.h.orig
>+++ include/osl/endian.h
>@@ -80,13 +80,11 @@
> #ifdef FREEBSD
> #   include <sys/param.h>
> #   include <machine/endian.h>
>-#if __FreeBSD_version < 500000
>-#   if BYTE_ORDER == LITTLE_ENDIAN
>-#       define _LITTLE_ENDIAN
>-#   elif BYTE_ORDER == BIG_ENDIAN
>-#       define _BIG_ENDIAN
>-#   endif
>-#endif
>+#   if BYTE_ORDER == LITTLE_ENDIAN
>+#   undef _BIG_ENDIAN
>+#   elif BYTE_ORDER == BIG_ENDIAN
>+#   undef _LITTLE_ENDIAN
>+#   endif
> #endif
> 
> #ifdef AIX
>--- include/tools/stream.hxx.orig
>+++ include/tools/stream.hxx
>@@ -27,6 +27,7 @@
> #include <tools/ref.hxx>
> #include <tools/rtti.hxx>
> #include <rtl/string.hxx>
>+#include <osl/endian.h>
> 
> class StreamData;
> 
>--- lotuswordpro/source/filter/lwpobjstrm.cxx.orig
>+++ lotuswordpro/source/filter/lwpobjstrm.cxx
>@@ -61,6 +61,8 @@
> #include "lwpobjstrm.hxx"
> #include "lwptools.hxx"
> #include <boost/scoped_array.hpp>
>+
>+#include <osl/endian.h>
> 
> /**
>  * @descr  ctor() from LwpSvStream
>--- oox/source/helper/binaryoutputstream.cxx.orig
>+++ oox/source/helper/binaryoutputstream.cxx
>@@ -23,6 +23,8 @@
> #include <com/sun/star/io/XSeekable.hpp>
> #include <osl/diagnose.h>
> #include <string.h>
>+
>+#include <osl/endian.h>
> 
> namespace oox {
> 
>--- store/workben/t_page.cxx.orig
>+++ store/workben/t_page.cxx
>@@ -26,6 +26,7 @@
> 
> #include "storbase.hxx"
> 
>+#include "osl/endian.h"
> #include "osl/file.h"
> #include "rtl/ustring.hxx"
> 
>--- sw/source/filter/ww8/ww8scan.cxx.orig
>+++ sw/source/filter/ww8/ww8scan.cxx
>@@ -23,6 +23,7 @@
> #include <functional>
> #include <algorithm>
> 
>+#include <osl/endian.h>
> #include <string.h>
> #include <i18nlangtag/mslangid.hxx>
> #include <sprmids.hxx>
>--- sw/source/filter/ww8/ww8scan.hxx.orig
>+++ sw/source/filter/ww8/ww8scan.hxx
>@@ -31,6 +31,7 @@
> #include <algorithm>
> 
> #include <boost/unordered_map.hpp>
>+#include <osl/endian.h>
> #include <tools/solar.h>
> #include <tools/stream.hxx>
> #include <rtl/ustring.hxx>
>--- sw/source/core/uibase/dochdl/swdtflvr.cxx.orig
>+++ sw/source/core/uibase/dochdl/swdtflvr.cxx
>@@ -118,6 +118,8 @@
> #include <swserv.hxx>
> #include <switerator.hxx>
> 
>+#include <osl/endian.h>
>+
> #include <vcl/GraphicNativeTransform.hxx>
> #include <vcl/GraphicNativeMetadata.hxx>
> 
>--- testtools/CustomTarget_uno_test.mk.orig
>+++ testtools/CustomTarget_uno_test.mk
>@@ -13,17 +13,17 @@
> .PHONY : $(call gb_CustomTarget_get_target,testtools/uno_test)
> 
> $(call gb_CustomTarget_get_target,testtools/uno_test) : \
>-		$(call gb_Executable_get_runtime_dependencies,uno) \
>-		$(call gb_InternalUnoApi_get_target,bridgetest) \
>-		$(call gb_Rdb_get_target,uno_services) \
>-		$(call gb_Rdb_get_target,ure/services) \
>-		$(call gb_UnoApi_get_target,udkapi)
>-	$(call gb_Helper_abbreviate_dirs,\
>-		$(call gb_Executable_get_command,uno) \
>-		-s com.sun.star.test.bridge.BridgeTest \
>-		-- com.sun.star.test.bridge.CppTestObject \
>-		-env:LO_BUILD_LIB_DIR=$(call gb_Helper_make_url,$(gb_Library_WORKDIR_FOR_BUILD)) \
>-		-env:URE_MORE_SERVICES=$(call gb_Helper_make_url,$(call gb_Rdb_get_target,uno_services)) \
>-		-env:URE_MORE_TYPES=$(call gb_Helper_make_url,$(WORKDIR)/UnoApiTarget/bridgetest.rdb))
>+#		$(call gb_Executable_get_runtime_dependencies,uno) \
>+#		$(call gb_InternalUnoApi_get_target,bridgetest) \
>+#		$(call gb_Rdb_get_target,uno_services) \
>+#		$(call gb_Rdb_get_target,ure/services) \
>+#		$(call gb_UnoApi_get_target,udkapi)
>+#	$(call gb_Helper_abbreviate_dirs,\
>+#		$(call gb_Executable_get_command,uno) \
>+#		-s com.sun.star.test.bridge.BridgeTest \
>+#		-- com.sun.star.test.bridge.CppTestObject \
>+#		-env:LO_BUILD_LIB_DIR=$(call gb_Helper_make_url,$(gb_Library_WORKDIR_FOR_BUILD)) \
>+#		-env:URE_MORE_SERVICES=$(call gb_Helper_make_url,$(call gb_Rdb_get_target,uno_services)) \
>+#		-env:URE_MORE_TYPES=$(call gb_Helper_make_url,$(WORKDIR)/UnoApiTarget/bridgetest.rdb))
> 
> # vim:set shiftwidth=4 tabstop=4 noexpandtab:
>--- vcl/generic/glyphs/gcach_ftyp.cxx.orig
>+++ vcl/generic/glyphs/gcach_ftyp.cxx
>@@ -36,6 +36,7 @@
> #include "basegfx/matrix/b2dhommatrixtools.hxx"
> #include "basegfx/polygon/b2dpolypolygon.hxx"
> 
>+#include "osl/endian.h"
> #include "osl/file.hxx"
> #include "osl/thread.hxx"
> 
>--- vcl/headless/svpvd.cxx.orig
>+++ vcl/headless/svpvd.cxx
>@@ -18,6 +18,8 @@
>  */
> 
> #ifndef IOS
>+
>+#include <osl/endian.h>
> 
> #include "headless/svpbmp.hxx"
> #include "headless/svpvd.hxx"
>--- vcl/headless/svpgdi.cxx.orig
>+++ vcl/headless/svpgdi.cxx
>@@ -21,6 +21,8 @@
> #include "headless/svpbmp.hxx"
> #include "saldatabasic.hxx"
> 
>+#include <osl/endian.h>
>+
> #include <vcl/sysdata.hxx>
> #include <basegfx/range/b2drange.hxx>
> #include <basegfx/range/b2ibox.hxx>
>--- vcl/headless/svpbmp.cxx.orig
>+++ vcl/headless/svpbmp.cxx
>@@ -26,6 +26,8 @@
> #include <basebmp/scanlineformats.hxx>
> #include <basebmp/color.hxx>
> 
>+#include <osl/endian.h>
>+
> #include <vcl/salbtype.hxx>
> #include <vcl/bitmap.hxx>
> 
>--- vcl/source/filter/jpeg/Exif.cxx.orig
>+++ vcl/source/filter/jpeg/Exif.cxx
>@@ -19,6 +19,7 @@
> 
> #include "Exif.hxx"
> #include <boost/scoped_array.hpp>
>+#include <osl/endian.h>
> 
> Exif::Exif() :
>     maOrientation(TOP_LEFT),

Actions: View | Diff

Attachments on bug 200020: 156448 | 156449 | 156915 | 177718 | 177763 | 178310 | 178631