Skip to content

C
core
Kaydet (Commit) 7e1489bb authored tarafından jan Iversen's avatar jan Iversen
Dosyalara gözat
Seçenekler

iOS, remove support for 32bit (arm). 

Supporting 32bit iOS, means a.o. adding several libraries to
the dependency list because macOSX does not install them by
default (e.g. zlib).

32bit is only used in old iPhones.

updated configure.ac
removed from solenv/gbuild/platform
bridges corrected

Change-Id: I415e744a9cb4acb3b5fbfca33c22940a1d56e390
üst 2e9eff73
Hide whitespace changes
Inline Side-by-side
Showing with 17 additions and 1349 deletions
bridges/CustomTarget_gcc3_ios_arm.mk → bridges/CustomTarget_gcc3_ios.mk
Dosyayı görüntüle @ 7e1489bb
...@@ -7,14 +7,14 @@ ...@@ -7,14 +7,14 @@
# file, You can obtain one at http://mozilla.org/MPL/2.0/. # file, You can obtain one at http://mozilla.org/MPL/2.0/.
# #
$(eval $(call gb_CustomTarget_CustomTarget,bridges/source/cpp_uno/gcc3_ios_arm)) $(eval $(call gb_CustomTarget_CustomTarget,bridges/source/cpp_uno/gcc3_ios))
$(call gb_CustomTarget_get_target,bridges/source/cpp_uno/gcc3_ios_arm) : \ $(call gb_CustomTarget_get_target,bridges/source/cpp_uno/gcc3_ios) : \
$(call gb_CustomTarget_get_workdir,bridges/source/cpp_uno/gcc3_ios_arm)/codesnippets.S $(call gb_CustomTarget_get_workdir,bridges/source/cpp_uno/gcc3_ios)/codesnippets.S
$(call gb_CustomTarget_get_workdir,bridges/source/cpp_uno/gcc3_ios_arm)/codesnippets.S : \ $(call gb_CustomTarget_get_workdir,bridges/source/cpp_uno/gcc3_ios)/codesnippets.S : \
$(SRCDIR)/bridges/source/cpp_uno/gcc3_ios_arm/generate-snippets.pl \ $(SRCDIR)/bridges/source/cpp_uno/gcc3_ios/generate-snippets.pl \
| $(call gb_CustomTarget_get_workdir,bridges/source/cpp_uno/gcc3_ios_arm)/.dir | $(call gb_CustomTarget_get_workdir,bridges/source/cpp_uno/gcc3_ios)/.dir
$(PERL) $< > $@ $(PERL) $< > $@
# vim: set noet sw=4 ts=4: # vim: set noet sw=4 ts=4:
bridges/Library_cpp_uno.mk
Dosyayı görüntüle @ 7e1489bb
...@@ -10,18 +10,8 @@ ...@@ -10,18 +10,8 @@
$(eval $(call gb_Library_Library,$(gb_CPPU_ENV)_uno)) $(eval $(call gb_Library_Library,$(gb_CPPU_ENV)_uno))
ifeq ($(OS),IOS) ifeq ($(OS),IOS)
bridges_SELECTED_BRIDGE := gcc3_ios_arm bridges_SELECTED_BRIDGE := gcc3_ios
bridge_noopt_objects := cpp2uno except uno2cpp bridge_noopt_objects := cpp2uno cpp2uno-arm64 cpp2uno-i386 except uno2cpp uno2cpp-arm64 uno2cpp-i386
# HACK
#$(call gb_LinkTarget_get_target,$(call gb_Library_get_linktarget,gcc3_uno)) : \
# $(call gb_CustomTarget_get_workdir,bridges/source/cpp_uno/gcc3_linux_arm)/armhelper.objectlist
#$(call gb_LinkTarget_get_target,$(call gb_Library_get_linktarget,gcc3_uno)) : \
# EXTRAOBJECTLISTS += $(call gb_CustomTarget_get_workdir,bridges/source/cpp_uno/gcc3_linux_arm)/armhelper.objectlist
#$(eval $(call gb_Library_use_sdk_api,gcc3_uno))
#bridge_asm_objects := helper
#bridge_exception_objects := cpp2uno cpp2uno-arm cpp2uno-arm64 cpp2uno-i386 except uno2cpp uno2cpp-arm uno2cpp-arm64 uno2cpp-i386
#$(eval $(call gb_Library_use_custom_headers,gcc3_uno,bridges/source/cpp_uno/gcc3_ios_arm))
else ifeq ($(CPUNAME),ARM) else ifeq ($(CPUNAME),ARM)
......
bridges/Module_bridges.mk
Dosyayı görüntüle @ 7e1489bb
...@@ -18,7 +18,7 @@ $(eval $(call gb_Module_add_targets,bridges,\ ...@@ -18,7 +18,7 @@ $(eval $(call gb_Module_add_targets,bridges,\
) \ ) \
$(if $(filter ARM,$(CPUNAME)),\ $(if $(filter ARM,$(CPUNAME)),\
$(if $(filter IOS,$(OS)),\ $(if $(filter IOS,$(OS)),\
CustomTarget_gcc3_ios_arm) \ CustomTarget_gcc3_ios) \
$(if $(filter ANDROID LINUX,$(OS)),\ $(if $(filter ANDROID LINUX,$(OS)),\
CustomTarget_gcc3_linux_arm) \ CustomTarget_gcc3_linux_arm) \
) \ ) \
......
bridges/source/cpp_uno/gcc3_ios_arm/share.hxx → bridges/source/cpp_uno/gcc3_ios/share.hxx
Dosyayı görüntüle @ 7e1489bb
...@@ -16,8 +16,8 @@ ...@@ -16,8 +16,8 @@
* except in compliance with the License. You may obtain a copy of * except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 . * the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/ */
#ifndef INCLUDED_BRIDGES_SOURCE_CPP_UNO_GCC3_IOS_ARM_SHARE_HXX #ifndef INCLUDED_BRIDGES_SOURCE_CPP_UNO_GCC3_IOS_SHARE_HXX
#define INCLUDED_BRIDGES_SOURCE_CPP_UNO_GCC3_IOS_ARM_SHARE_HXX #define INCLUDED_BRIDGES_SOURCE_CPP_UNO_GCC3_IOS_SHARE_HXX
#include "uno/mapping.h" #include "uno/mapping.h"
......
bridges/source/cpp_uno/gcc3_ios_arm/cpp2uno-arm.cxx deleted 100644 → 0
Dosyayı görüntüle @ 2e9eff73
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#ifdef __arm
// For iOS devices (ARM). Basically a copy of
// ../gcc3_linux_arm/cpp2uno.cxx with some cleanups and necessary
// changes: No dynamic code generation as that is prohibited for apps
// in the App Store. Instead we use a set of pre-generated snippets.
// No attempts at factoring out the large amounts of more or less
// common code in this and cpp2uno-i386.cxx have been done. Which is
// sad. But then the whole bridges/source/cpp_uno is full of
// copy/paste. So I continue in that tradition...
// Note that for iOS, neither __ARM_EABI__ or __ARM_PCS_VFP are
// defined. The ifdefs for those have been left in place to keep this
// file as close to ../gcc3_linux_arm/cpp2uno.cxx as possible, to make
// future unification easier.
#include <com/sun/star/uno/RuntimeException.hpp>
#include <sal/log.hxx>
#include <uno/data.h>
#include <typelib/typedescription.hxx>
#include "bridge.hxx"
#include "cppinterfaceproxy.hxx"
#include "types.hxx"
#include "vtablefactory.hxx"
#include "share.hxx"
extern "C" {
extern int nFunIndexes, nVtableOffsets;
extern int codeSnippets[];
}
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,
sal_Int32 nParams, typelib_MethodParameter * pParams,
void ** pCallStack,
sal_Int64 * pRegisterReturn /* space for register return */ )
{
// pCallStack: ret, [return ptr], this, params
char * pTopStack = (char *)(pCallStack + 0);
char * pCppStack = pTopStack;
#ifdef __ARM_PCS_VFP
int dc = 0;
char * pFloatArgs = (char *)(pCppStack - 64);
#endif
// return
typelib_TypeDescription * pReturnTypeDescr = 0;
if (pReturnTypeRef)
TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
void * pUnoReturn = 0;
// complex return ptr: if != 0 && != pUnoReturn, reconversion need
void * pCppReturn = 0;
if (pReturnTypeDescr)
{
if (!arm::return_in_hidden_param(pReturnTypeRef))
pUnoReturn = pRegisterReturn; // direct way for simple types
else // complex return via ptr (pCppReturn)
{
pCppReturn = *(void **)pCppStack;
pCppStack += sizeof(void *);
pUnoReturn = (bridges::cpp_uno::shared::relatesToInterfaceType(
pReturnTypeDescr )
? alloca( pReturnTypeDescr->nSize )
: pCppReturn); // direct way
}
}
// pop this
pCppStack += sizeof( void* );
// stack space
static_assert( sizeof(void *) == sizeof(sal_Int32),
"### 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;
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 (!rParam.bOut &&
bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
{
#ifdef __ARM_EABI__
switch (pParamTypeDescr->eTypeClass)
{
case typelib_TypeClass_HYPER:
case typelib_TypeClass_UNSIGNED_HYPER:
#ifndef __ARM_PCS_VFP
case typelib_TypeClass_DOUBLE:
#endif
if ((pCppStack - pTopStack) % 8) pCppStack+=sizeof(sal_Int32); //align to 8
break;
default:
break;
}
#endif
// For armhf we get the floating point arguments from a different area of the stack
#ifdef __ARM_PCS_VFP
if (pParamTypeDescr->eTypeClass == typelib_TypeClass_FLOAT)
{
pCppArgs[nPos] = pUnoArgs[nPos] = pFloatArgs;
pFloatArgs += sizeof(float);
} else
if (pParamTypeDescr->eTypeClass == typelib_TypeClass_DOUBLE)
{
if ((pFloatArgs - pTopStack) % 8) pFloatArgs+=sizeof(float); //align to 8
pCppArgs[nPos] = pUnoArgs[nPos] = pFloatArgs;
pFloatArgs += sizeof(double);
if (++dc == arm::MAX_FPR_REGS) {
if (pCppStack - pTopStack < 16)
pCppStack = pTopStack + 16;
pFloatArgs = pCppStack;
}
} else
#endif
pCppArgs[nPos] = pUnoArgs[nPos] = pCppStack;
switch (pParamTypeDescr->eTypeClass)
{
case typelib_TypeClass_HYPER:
case typelib_TypeClass_UNSIGNED_HYPER:
#ifndef __ARM_PCS_VFP
case typelib_TypeClass_DOUBLE:
#endif
pCppStack += sizeof(sal_Int32); // extra long
break;
default:
break;
}
// no longer needed
TYPELIB_DANGER_RELEASE( pParamTypeDescr );
}
else // ptr to complex value | ref
{
pCppArgs[nPos] = *(void **)pCppStack;
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 ),
*(void **)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] = *(void **)pCppStack;
// no longer needed
TYPELIB_DANGER_RELEASE( pParamTypeDescr );
}
}
#ifdef __ARM_PCS_VFP
// use the stack for output parameters or non floating point values
if (rParam.bOut ||
((pParamTypeDescr->eTypeClass != typelib_TypeClass_DOUBLE)
&& (pParamTypeDescr->eTypeClass != typelib_TypeClass_FLOAT))
)
#endif
pCppStack += sizeof(sal_Int32); // standard parameter length
}
// 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 eax
*(void **)pRegisterReturn = pCppReturn;
}
if (pReturnTypeDescr)
{
typelib_TypeClass eRet =
(typelib_TypeClass)pReturnTypeDescr->eTypeClass;
TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
return eRet;
}
else
return typelib_TypeClass_VOID;
}
}
static typelib_TypeClass cpp_mediate(
sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset,
void ** pCallStack,
sal_Int64 * pRegisterReturn /* space for register return */ )
{
static_assert( sizeof(sal_Int32)==sizeof(void *), "### unexpected!" );
// pCallStack: [ret *], this, params
// _this_ ptr is patched cppu_XInterfaceProxy object
void *pThis;
if( nFunctionIndex & 0x80000000 )
{
nFunctionIndex &= 0x7fffffff;
pThis = pCallStack[1];
}
else
{
pThis = pCallStack[0];
}
pThis = static_cast< char * >(pThis) - nVtableOffset;
bridges::cpp_uno::shared::CppInterfaceProxy * pCppI =
bridges::cpp_uno::shared::CppInterfaceProxy::castInterfaceToProxy(
pThis);
typelib_InterfaceTypeDescription * pTypeDescr = pCppI->getTypeDescr();
assert( nFunctionIndex < pTypeDescr->nMapFunctionIndexToMemberIndex &&
"### illegal vtable index!" );
if (nFunctionIndex >= pTypeDescr->nMapFunctionIndexToMemberIndex)
{
throw RuntimeException( "illegal vtable index!", (XInterface *)pCppI );
}
// determine called method
assert( nFunctionIndex < pTypeDescr->nMapFunctionIndexToMemberIndex &&
"### illegal vtable index!" );
sal_Int32 nMemberPos =
pTypeDescr->pMapFunctionIndexToMemberIndex[nFunctionIndex];
assert( nMemberPos < pTypeDescr->nAllMembers &&
"### illegal member index!" );
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
pCallStack, 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,
pCallStack, 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 *>(pCallStack[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 * >( pCallStack[0] ),
&pInterface, pTD, cpp_acquire );
pInterface->release();
TYPELIB_DANGER_RELEASE( pTD );
*(void **)pRegisterReturn = pCallStack[0];
eRet = typelib_TypeClass_ANY;
break;
}
TYPELIB_DANGER_RELEASE( pTD );
}
} // else perform queryInterface()
SAL_FALLTHROUGH;
default:
eRet = cpp2uno_call(
pCppI, aMemberDescr.get(),
((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pReturnTypeRef,
((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->nParams,
((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pParams,
pCallStack, pRegisterReturn );
}
break;
}
default:
{
throw RuntimeException( "no member description found!", (XInterface *)pCppI );
}
}
return eRet;
}
}
/**
* is called on incoming vtable calls
* (called by asm snippets)
*/
extern "C" sal_Int64 cpp_vtable_call( long *pFunctionAndOffset,
void **pCallStack )
{
sal_Int64 nRegReturn;
typelib_TypeClass aType = cpp_mediate( pFunctionAndOffset[0], pFunctionAndOffset[1], pCallStack,
&nRegReturn );
switch( aType )
{
case typelib_TypeClass_BOOLEAN:
case typelib_TypeClass_BYTE:
nRegReturn = (unsigned long)(*(unsigned char *)&nRegReturn);
break;
case typelib_TypeClass_CHAR:
case typelib_TypeClass_UNSIGNED_SHORT:
case typelib_TypeClass_SHORT:
nRegReturn = (unsigned long)(*(unsigned short *)&nRegReturn);
break;
case typelib_TypeClass_ENUM:
case typelib_TypeClass_UNSIGNED_LONG:
case typelib_TypeClass_LONG:
nRegReturn = (unsigned long)(*(unsigned int *)&nRegReturn);
break;
case typelib_TypeClass_VOID:
default:
break;
}
return nRegReturn;
}
namespace
{
unsigned char *codeSnippet(const typelib_InterfaceTypeDescription *type,
const typelib_TypeDescription *member,
sal_Int32 functionIndex,
sal_Int32 vtableOffset,
bool bHasHiddenParam)
{
assert(functionIndex < nFunIndexes);
if (!(functionIndex < nFunIndexes))
return NULL;
assert(vtableOffset < nVtableOffsets);
if (!(vtableOffset < nVtableOffsets))
return NULL;
// The codeSnippets table is indexed by functionIndex,
// vtableOffset, and the has-hidden-param flag
int index = functionIndex*nVtableOffsets*2 + vtableOffset*2 + bHasHiddenParam;
unsigned char *result = ((unsigned char *) &codeSnippets) + codeSnippets[index];
SAL_INFO( "bridges.ios", "codeSnippet(" << OUString(type->aBase.pTypeName) << "::" << OUString(member->pTypeName) << "): [" << functionIndex << "," << vtableOffset << "," << (int)bHasHiddenParam << "]=" << (void *) result << " (" << std::hex << ((int*)result)[0] << "," << ((int*)result)[1] << "," << ((int*)result)[2] << "," << ((int*)result)[3] << ")");
return result;
}
}
struct bridges::cpp_uno::shared::VtableFactory::Slot { void * fn; };
bridges::cpp_uno::shared::VtableFactory::Slot *
bridges::cpp_uno::shared::VtableFactory::mapBlockToVtable(void * block)
{
return static_cast< Slot * >(block) + 2;
}
std::size_t bridges::cpp_uno::shared::VtableFactory::getBlockSize(
sal_Int32 slotCount)
{
return (slotCount + 2) * sizeof (Slot);
}
bridges::cpp_uno::shared::VtableFactory::Slot *
bridges::cpp_uno::shared::VtableFactory::initializeBlock(
void * block, sal_Int32 slotCount, sal_Int32,
typelib_InterfaceTypeDescription *)
{
Slot * slots = mapBlockToVtable(block);
slots[-2].fn = 0;
slots[-1].fn = 0;
return slots + slotCount;
}
unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
Slot ** slots, unsigned char * code,
typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,
sal_Int32 functionCount, sal_Int32 vtableOffset)
{
(*slots) -= functionCount;
Slot * s = *slots;
for (sal_Int32 i = 0; i < type->nMembers; ++i)
{
typelib_TypeDescription * member = 0;
TYPELIB_DANGER_GET(&member, type->ppMembers[i]);
assert(member != 0);
switch (member->eTypeClass)
{
case typelib_TypeClass_INTERFACE_ATTRIBUTE:
{
typelib_InterfaceAttributeTypeDescription *pAttrTD =
reinterpret_cast<typelib_InterfaceAttributeTypeDescription *>( member );
// Getter:
(s++)->fn = codeSnippet(type, member,
functionOffset++, vtableOffset,
arm::return_in_hidden_param( pAttrTD->pAttributeTypeRef ));
// Setter:
if (!pAttrTD->bReadOnly)
{
(s++)->fn = codeSnippet(type, member,
functionOffset++, vtableOffset,
false);
}
break;
}
case typelib_TypeClass_INTERFACE_METHOD:
{
typelib_InterfaceMethodTypeDescription *pMethodTD =
reinterpret_cast<
typelib_InterfaceMethodTypeDescription * >(member);
(s++)->fn = codeSnippet(type, member,
functionOffset++, vtableOffset,
arm::return_in_hidden_param(pMethodTD->pReturnTypeRef));
break;
}
default:
assert(false);
break;
}
TYPELIB_DANGER_RELEASE(member);
}
return code;
}
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
bridges/source/cpp_uno/gcc3_ios_arm/uno2cpp-arm.cxx deleted 100644 → 0
Dosyayı görüntüle @ 2e9eff73
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#ifdef __arm
// For iOS devices (ARM). Basically a copy of
// ../gcc3_linux_arm/cpp2uno.cxx with some cleanups and necessary
// changes.
// Note that for iOS, none of __ARM_EABI__, __ARM_ARCH_4T__ or
// __ARM_PCS_VFP are defined. The ifdefs for those have been left in
// place to keep this file as close to ../gcc3_linux_arm/uno2cpp.cxx
// as possible, to make future unification easier.
#include <com/sun/star/uno/RuntimeException.hpp>
#include <sal/log.hxx>
#include "bridge.hxx"
#include "types.hxx"
#include "unointerfaceproxy.hxx"
#include "vtables.hxx"
#include "share.hxx"
using namespace ::com::sun::star::uno;
namespace arm
{
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;
}
#ifdef __ARM_PCS_VFP
bool is_float_only_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_FLOAT &&
p->ppTypeRefs[i]->eTypeClass != typelib_TypeClass_DOUBLE)
return false;
}
return true;
}
#endif
bool return_in_hidden_param( typelib_TypeDescriptionReference *pTypeRef )
{
if (bridges::cpp_uno::shared::isSimpleType(pTypeRef))
return false;
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 4 bytes is returned in r0
bool bRet = pTypeDescr->nSize > 4 || is_complex_struct(pTypeDescr);
#ifdef __ARM_PCS_VFP
// In the VFP ABI, structs with only float/double values that fit in
// 16 bytes are returned in registers
if( pTypeDescr->nSize <= 16 && is_float_only_struct(pTypeDescr))
bRet = false;
#endif
TYPELIB_DANGER_RELEASE( pTypeDescr );
return bRet;
}
return true;
}
}
void MapReturn(sal_uInt32 r0, sal_uInt32 r1, typelib_TypeDescriptionReference * pReturnType, sal_uInt32* pRegisterReturn)
{
switch( pReturnType->eTypeClass )
{
case typelib_TypeClass_HYPER:
case typelib_TypeClass_UNSIGNED_HYPER:
pRegisterReturn[1] = r1;
SAL_FALLTHROUGH;
case typelib_TypeClass_LONG:
case typelib_TypeClass_UNSIGNED_LONG:
case typelib_TypeClass_ENUM:
case typelib_TypeClass_CHAR:
case typelib_TypeClass_SHORT:
case typelib_TypeClass_UNSIGNED_SHORT:
case typelib_TypeClass_BOOLEAN:
case typelib_TypeClass_BYTE:
pRegisterReturn[0] = r0;
break;
case typelib_TypeClass_FLOAT:
#if !defined(__ARM_PCS_VFP) && (defined(__ARM_EABI__) || defined(__SOFTFP__) || defined(IOS))
pRegisterReturn[0] = r0;
#else
register float fret asm("s0");
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wuninitialized"
*(float*)pRegisterReturn = fret;
#pragma GCC diagnostic pop
#endif
break;
case typelib_TypeClass_DOUBLE:
#if !defined(__ARM_PCS_VFP) && (defined(__ARM_EABI__) || defined(__SOFTFP__) || defined(IOS))
pRegisterReturn[1] = r1;
pRegisterReturn[0] = r0;
#else
register double dret asm("d0");
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wuninitialized"
*(double*)pRegisterReturn = dret;
#pragma GCC diagnostic pop
#endif
break;
case typelib_TypeClass_STRUCT:
case typelib_TypeClass_EXCEPTION:
{
if (!arm::return_in_hidden_param(pReturnType))
pRegisterReturn[0] = r0;
break;
}
default:
break;
}
}
namespace
{
void callVirtualMethod(
void * pThis,
sal_Int32 nVtableIndex,
void * pRegisterReturn,
typelib_TypeDescriptionReference * pReturnType,
sal_uInt32 *pStack,
sal_uInt32 nStack,
sal_uInt32 *pGPR,
sal_uInt32 nGPR,
double *pFPR) __attribute__((noinline));
void callVirtualMethod(
void * pThis,
sal_Int32 nVtableIndex,
void * pRegisterReturn,
typelib_TypeDescriptionReference * pReturnType,
sal_uInt32 *pStack,
sal_uInt32 nStack,
sal_uInt32 *pGPR,
sal_uInt32 nGPR,
double *pFPR)
{
// never called
if (! pThis)
CPPU_CURRENT_NAMESPACE::dummy_can_throw_anything("xxx"); // address something
if ( nStack )
{
// 8-bytes aligned
sal_uInt32 nStackBytes = ( ( nStack + 1 ) >> 1 ) * 8;
sal_uInt32 *stack = (sal_uInt32 *) __builtin_alloca( nStackBytes );
memcpy( stack, pStack, nStackBytes );
}
// Should not happen, but...
if ( nGPR > arm::MAX_GPR_REGS )
nGPR = arm::MAX_GPR_REGS;
sal_uInt32 pMethod = *((sal_uInt32*)pThis);
pMethod += 4 * nVtableIndex;
pMethod = *((sal_uInt32 *)pMethod);
//Return registers
sal_uInt32 r0;
sal_uInt32 r1;
__asm__ __volatile__ (
//Fill in general purpose register arguments
"ldr r4, %[pgpr]\n\t"
"ldmia r4, {r0-r3}\n\t"
#ifdef __ARM_PCS_VFP
//Fill in VFP register arguments as double precision values
"ldr r4, %[pfpr]\n\t"
"vldmia r4, {d0-d7}\n\t"
#endif
//Make the call
"ldr r5, %[pmethod]\n\t"
#ifndef __ARM_ARCH_4T__
"blx r5\n\t"
#else
"mov lr, pc ; bx r5\n\t"
#endif
//Fill in return values
"mov %[r0], r0\n\t"
"mov %[r1], r1\n\t"
: [r0]"=r" (r0), [r1]"=r" (r1)
: [pmethod]"m" (pMethod), [pgpr]"m" (pGPR), [pfpr]"m" (pFPR)
: "r0", "r1", "r2", "r3", "r4", "r5");
MapReturn(r0, r1, pReturnType, (sal_uInt32*)pRegisterReturn);
}
}
#define INSERT_INT32( pSV, nr, pGPR, pDS ) \
if ( nr < arm::MAX_GPR_REGS ) \
pGPR[nr++] = *reinterpret_cast<sal_uInt32 *>( pSV ); \
else \
*pDS++ = *reinterpret_cast<sal_uInt32 *>( pSV );
#ifdef __ARM_EABI__
#define INSERT_INT64( pSV, nr, pGPR, pDS, pStart ) \
if ( (nr < arm::MAX_GPR_REGS) && (nr % 2) ) \
{ \
++nr; \
} \
if ( nr < arm::MAX_GPR_REGS ) \
{ \
pGPR[nr++] = *reinterpret_cast<sal_uInt32 *>( pSV ); \
pGPR[nr++] = *(reinterpret_cast<sal_uInt32 *>( pSV ) + 1); \
} \
else \
{ \
if ( (pDS - pStart) % 2) \
{ \
++pDS; \
} \
*pDS++ = reinterpret_cast<sal_uInt32 *>( pSV )[0]; \
*pDS++ = reinterpret_cast<sal_uInt32 *>( pSV )[1]; \
}
#else
#define INSERT_INT64( pSV, nr, pGPR, pDS, pStart ) \
INSERT_INT32( pSV, nr, pGPR, pDS ) \
INSERT_INT32( ((sal_uInt32*)pSV)+1, nr, pGPR, pDS )
#endif
#ifdef __ARM_PCS_VFP
// Since single and double arguments share the same register bank the filling of the
// registers is not always linear. Single values go to the first available single register,
// while doubles need to have an 8 byte alignment, so only go into double registers starting
// at every other single register. For ex a float, double, float sequence will fill registers
// s0, d1, and s1, actually corresponding to the linear order s0,s1, d1.
//
// These use the single/double register array and counters and ignore the pGPR argument
// nSR and nDR are the number of single and double precision registers that are no longer
// available
#define INSERT_FLOAT( pSV, nr, pGPR, pDS ) \
if (nSR % 2 == 0) {\
nSR = 2*nDR; \
}\
if ( nSR < arm::MAX_FPR_REGS*2 ) {\
pSPR[nSR++] = *reinterpret_cast<float *>( pSV ); \
if ((nSR % 2 == 1) && (nSR > 2*nDR)) {\
nDR++; \
}\
}\
else \
{\
*pDS++ = *reinterpret_cast<float *>( pSV );\
}
#define INSERT_DOUBLE( pSV, nr, pGPR, pDS, pStart ) \
if ( nDR < arm::MAX_FPR_REGS ) { \
pFPR[nDR++] = *reinterpret_cast<double *>( pSV ); \
}\
else\
{\
if ( (pDS - pStart) % 2) \
{ \
++pDS; \
} \
*(double *)pDS = *reinterpret_cast<double *>( pSV );\
pDS += 2;\
}
#else
#define INSERT_FLOAT( pSV, nr, pFPR, pDS ) \
INSERT_INT32( pSV, nr, pGPR, pDS )
#define INSERT_DOUBLE( pSV, nr, pFPR, pDS, pStart ) \
INSERT_INT64( pSV, nr, pGPR, pDS, pStart )
#endif
#define INSERT_INT16( pSV, nr, pGPR, pDS ) \
if ( nr < arm::MAX_GPR_REGS ) \
pGPR[nr++] = *reinterpret_cast<sal_uInt16 *>( pSV ); \
else \
*pDS++ = *reinterpret_cast<sal_uInt16 *>( pSV );
#define INSERT_INT8( pSV, nr, pGPR, pDS ) \
if ( nr < arm::MAX_GPR_REGS ) \
pGPR[nr++] = *reinterpret_cast<sal_uInt8 *>( pSV ); \
else \
*pDS++ = *reinterpret_cast<sal_uInt8 *>( pSV );
namespace {
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_uInt32 * pStack = (sal_uInt32 *)__builtin_alloca(
sizeof(sal_Int32) + ((nParams+2) * sizeof(sal_Int64)) );
sal_uInt32 * pStackStart = pStack;
sal_uInt32 pGPR[arm::MAX_GPR_REGS];
sal_uInt32 nGPR = 0;
// storage and counters for single and double precision VFP registers
double pFPR[arm::MAX_FPR_REGS];
#ifdef __ARM_PCS_VFP
sal_uInt32 nDR = 0;
float *pSPR = reinterpret_cast< float *>(&pFPR);
sal_uInt32 nSR = 0;
#endif
// return
typelib_TypeDescription * pReturnTypeDescr = 0;
TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
assert(pReturnTypeDescr);
void * pCppReturn = 0; // if != 0 && != pUnoReturn, needs reconversion
if (pReturnTypeDescr)
{
bool bSimpleReturn = !arm::return_in_hidden_param( pReturnTypeRef );
if (bSimpleReturn)
pCppReturn = pUnoReturn; // direct way for simple types
else
{
// complex return via ptr
pCppReturn = (bridges::cpp_uno::shared::relatesToInterfaceType( pReturnTypeDescr )
? __builtin_alloca( pReturnTypeDescr->nSize )
: pUnoReturn); // direct way
INSERT_INT32( &pCppReturn, nGPR, pGPR, pStack );
}
}
// push this
void * pAdjustedThisPtr = reinterpret_cast< void ** >(pThis->getCppI())
+ aVtableSlot.offset;
INSERT_INT32( &pAdjustedThisPtr, nGPR, pGPR, pStack );
// stack space
static_assert(sizeof(void *) == sizeof(sal_Int32), "### unexpected size!");
// 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;
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 (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
{
// uno_copyAndConvertData( pCppArgs[nPos] = pStack, pUnoArgs[nPos],
uno_copyAndConvertData( pCppArgs[nPos] = alloca(8), pUnoArgs[nPos],
pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
switch (pParamTypeDescr->eTypeClass)
{
case typelib_TypeClass_HYPER:
case typelib_TypeClass_UNSIGNED_HYPER:
SAL_INFO( "bridges.ios", "hyper is " << pCppArgs[nPos] );
INSERT_INT64( pCppArgs[nPos], nGPR, pGPR, pStack, pStackStart );
break;
case typelib_TypeClass_LONG:
case typelib_TypeClass_UNSIGNED_LONG:
case typelib_TypeClass_ENUM:
SAL_INFO( "bridges.ios", "long is " << pCppArgs[nPos] );
INSERT_INT32( pCppArgs[nPos], nGPR, pGPR, pStack );
break;
case typelib_TypeClass_SHORT:
case typelib_TypeClass_CHAR:
case typelib_TypeClass_UNSIGNED_SHORT:
INSERT_INT16( pCppArgs[nPos], nGPR, pGPR, pStack );
break;
case typelib_TypeClass_BOOLEAN:
case typelib_TypeClass_BYTE:
INSERT_INT8( pCppArgs[nPos], nGPR, pGPR, pStack );
break;
case typelib_TypeClass_FLOAT:
INSERT_FLOAT( pCppArgs[nPos], nGPR, pGPR, pStack );
break;
case typelib_TypeClass_DOUBLE:
INSERT_DOUBLE( pCppArgs[nPos], nGPR, pGPR, pStack, pStackStart );
break;
default:
break;
}
// no longer needed
TYPELIB_DANGER_RELEASE( pParamTypeDescr );
}
else // ptr to complex value | ref
{
if (! rParam.bIn) // is pure out
{
// cpp out is constructed mem, uno out is not!
uno_constructData(
pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
pParamTypeDescr );
pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
// will be released at reconversion
ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
}
// is in/inout
else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
{
uno_copyAndConvertData(
pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
pTempIndices[nTempIndices] = nPos; // has to be reconverted
// will be released at reconversion
ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
}
else // direct way
{
pCppArgs[nPos] = pUnoArgs[nPos];
// no longer needed
TYPELIB_DANGER_RELEASE( pParamTypeDescr );
}
INSERT_INT32( &(pCppArgs[nPos]), nGPR, pGPR, pStack );
}
}
try
{
callVirtualMethod(
pAdjustedThisPtr, aVtableSlot.index,
pCppReturn, pReturnTypeRef,
pStackStart,
(pStack - pStackStart),
pGPR, nGPR,
pFPR);
// 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 (...)
{
// __asm__ __volatile__ ("sub sp, sp, #2048\n");
// fill uno exception
CPPU_CURRENT_NAMESPACE::fillUnoException( abi::__cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
// temporary params
for ( ; nTempIndices--; )
{
sal_Int32 nIndex = pTempIndices[nTempIndices];
// destroy temp cpp param => cpp: every param was constructed
uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
}
// return type
if (pReturnTypeDescr)
TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
}
}
}
namespace bridges { namespace cpp_uno { namespace shared {
void unoInterfaceProxyDispatch(
uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr,
void * pReturn, void * pArgs[], uno_Any ** ppException )
{
// is my surrogate
bridges::cpp_uno::shared::UnoInterfaceProxy * pThis
= static_cast< bridges::cpp_uno::shared::UnoInterfaceProxy * >(pUnoI);
#if OSL_DEBUG_LEVEL > 0
typelib_InterfaceTypeDescription * pTypeDescr = pThis->pTypeDescr;
#endif
switch (pMemberDescr->eTypeClass)
{
case typelib_TypeClass_INTERFACE_ATTRIBUTE:
{
#if OSL_DEBUG_LEVEL > 0
// determine vtable call index
sal_Int32 nMemberPos = ((typelib_InterfaceMemberTypeDescription *)pMemberDescr)->nPosition;
assert(nMemberPos < pTypeDescr->nAllMembers && "### member pos out of range!");
#endif
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;
cpp_call(
pThis, aVtableSlot, // get, then set method
pReturnTypeRef,
1, &aParam,
pReturn, pArgs, ppException );
typelib_typedescriptionreference_release( pReturnTypeRef );
}
break;
}
case typelib_TypeClass_INTERFACE_METHOD:
{
#if OSL_DEBUG_LEVEL > 0
// determine vtable call index
sal_Int32 nMemberPos = ((typelib_InterfaceMemberTypeDescription *)pMemberDescr)->nPosition;
assert(nMemberPos < pTypeDescr->nAllMembers && "### member pos out of range!");
#endif
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->getBridge()->getUnoEnv()->getRegisteredInterface)(
pThis->getBridge()->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()
SAL_FALLTHROUGH;
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(
"illegal member type description!",
::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >() );
Type const & rExcType = cppu::UnoType<decltype(aExc)>::get();
// binary identical null reference
::uno_type_any_construct( *ppException, &aExc, rExcType.getTypeLibType(), 0 );
}
}
}
} } }
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
configure.ac
Dosyayı görüntüle @ 7e1489bb
...@@ -620,7 +620,7 @@ darwin*) # Mac OS X or iOS ...@@ -620,7 +620,7 @@ darwin*) # Mac OS X or iOS
test_freetype=no test_freetype=no
test_fontconfig=no test_fontconfig=no
test_dbus=no test_dbus=no
if test "$host_cpu" = "arm" -o "$host_cpu" = "arm64"; then if test "$host_cpu" = "arm64"; then
_os=iOS _os=iOS
test_gtk=no test_gtk=no
test_cups=no test_cups=no
...@@ -2391,8 +2391,9 @@ if test -z "$enable_database_connectivity"; then ...@@ -2391,8 +2391,9 @@ if test -z "$enable_database_connectivity"; then
# --disable-database-connectivity is unfinished work in progress # --disable-database-connectivity is unfinished work in progress
# and the iOS test app doesn't link if we actually try to use it. # and the iOS test app doesn't link if we actually try to use it.
# if test $_os != iOS -a $_os != Android; then # if test $_os != iOS -a $_os != Android; then
if test $_os != iOS; then
enable_database_connectivity=yes enable_database_connectivity=yes
# fi fi
fi fi
if test "$enable_database_connectivity" = yes; then if test "$enable_database_connectivity" = yes; then
...@@ -3066,7 +3067,7 @@ if test "$_os" = "WINNT"; then ...@@ -3066,7 +3067,7 @@ if test "$_os" = "WINNT"; then
fi fi
fi fi
if test "$_os" = "iOS"; then if test "$_os" = "iOS"; then
if test "$host_cpu" = "arm" -o "$host_cpu" = "arm64" ; then if test "$host_cpu" = "arm64" ; then
cross_compiling="yes" cross_compiling="yes"
fi fi
fi fi
...@@ -3936,16 +3937,7 @@ darwin*) ...@@ -3936,16 +3937,7 @@ darwin*)
case "$host_cpu" in case "$host_cpu" in
arm) arm)
OS=IOS AC_MSG_ERROR([Can't build 32-bit code for iOS])
if test "$enable_ios_simulator" = "yes"; then
CPUNAME=I386
RTL_ARCH=x86
PLATFORMID=macosx_x86
else
RTL_ARCH=ARM_EABI
CPUNAME=ARM
PLATFORMID=ios_arm
fi
;; ;;
arm64) arm64)
OS=IOS OS=IOS
...@@ -5577,14 +5569,7 @@ dnl =================================================================== ...@@ -5577,14 +5569,7 @@ dnl ===================================================================
if test "$_os" != "WINNT"; then if test "$_os" != "WINNT"; then
if test "$_os" == "iOS"; then if test "$_os" == "iOS"; then
if test "$host_cpu" == "arm"; then if test "$host_cpu" == "arm64"; then
ac_cv_sizeof_long=4
ac_cv_sizeof_short=2
ac_cv_sizeof_int=4
ac_cv_sizeof_long_long=8
ac_cv_sizeof_double=8
ac_cv_sizeof_voidp=4
else
ac_cv_sizeof_long=8 ac_cv_sizeof_long=8
ac_cv_sizeof_short=2 ac_cv_sizeof_short=2
ac_cv_sizeof_int=4 ac_cv_sizeof_int=4
......
solenv/gbuild/platform/iOS_ARM_GCC.mk deleted 100644 → 0
Dosyayı görüntüle @ 2e9eff73
# -*- 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/.
#
# 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 .
#
gb_CPUDEFS := -DARM32
include $(GBUILDDIR)/platform/iOS.mk
solenv/gbuild/platform/iOS_I386_GCC.mk deleted 100644 → 0
Dosyayı görüntüle @ 2e9eff73
# -*- 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/.
#
# 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 .
#
gb_CPUDEFS := -DI386
include $(GBUILDDIR)/platform/iOS.mk
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment