FreeBSD Bugzilla – Attachment 177763 Details for
Bug 200020
[patch] editors/libreoffice: enable build on powerpc64
Home
|
New
|
Browse
|
Search
|
[?]
|
Reports
|
Help
|
New Account
|
Log In
Remember
[x]
|
Forgot Password
Login:
[x]
[patch]
Libreoffice4 ports patch
enable_powerpc64_build.patch (text/plain), 73.26 KB, created by
Curtis Hamilton
on 2016-12-07 19:00:16 UTC
(
hide
)
Description:
Libreoffice4 ports patch
Filename:
MIME Type:
Creator:
Curtis Hamilton
Created:
2016-12-07 19:00:16 UTC
Size:
73.26 KB
patch
obsolete
>--- Makefile.orig >+++ Makefile >@@ -79,7 +79,7 @@ > ${LOCALBASE}/share/fonts/LinLibertineG/LinLibertine_DR_G.ttf:x11-fonts/linuxlibertine-g > > CONFLICTS_INSTALL= libreoffice-5.* >-ONLY_FOR_ARCHS= amd64 i386 >+ONLY_FOR_ARCHS= amd64 i386 powerpc64 > > _MAKE_JOBS= # > >@@ -101,6 +101,11 @@ > > EXTRA_PATCHES= ${FILESDIR}/enable-opencollada:-p1 > WRKSRC= ${WRKDIR}/${PORTNAME}-${LOVERSION} >+ >+.if ${ARCH} == "powerpc64" >+EXTRA_PATCHES+= ${FILESDIR}/extra-enable_powerpc64.patch >+USE_GCC= 4.8+ >+.endif > > COLLADA_MODS= COLLADABaseUtils COLLADAFramework \ > COLLADASaxFrameworkLoader GeneratedSaxParser >--- /dev/null >+++ files/extra-enable_powerpc64.patch >@@ -0,0 +1,2081 @@ >+--- 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),
<b>You cannot view the attachment while viewing its details because your browser does not support IFRAMEs. <a href="attachment.cgi?id=177763">View the attachment on a separate page</a>.</b>
View Attachment As Diff
View Attachment As Raw
Actions:
View
|
Diff
Attachments on
bug 200020
:
156448
|
156449
|
156915
|
177718
| 177763 |
178310
|
178631