LibreOffice Module bridges (master) 1
gcc3_linux_arm/cpp2uno.cxx
Go to the documentation of this file.
1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20#include <malloc.h>
21
22#include <rtl/alloc.h>
23#include <sal/log.hxx>
24
25#include <com/sun/star/uno/genfunc.hxx>
26#include <com/sun/star/uno/RuntimeException.hpp>
27#include <uno/data.h>
28#include <typelib/typedescription.hxx>
29
30#include <bridge.hxx>
31#include <cppinterfaceproxy.hxx>
32#include <types.hxx>
33#include <vtablefactory.hxx>
34
35#include "share.hxx"
36#include "call.hxx"
37
38#include <dlfcn.h>
39
40#ifdef ANDROID
41#include <unistd.h>
42#endif
43
44using namespace ::osl;
45using namespace ::com::sun::star::uno;
46
47namespace
48{
49
50 typelib_TypeClass cpp2uno_call(
52 const typelib_TypeDescription * pMemberTypeDescr,
53 typelib_TypeDescriptionReference * pReturnTypeRef,
54 sal_Int32 nParams, typelib_MethodParameter * pParams,
55 void ** pCallStack,
56 sal_Int64 * pRegisterReturn /* space for register return */ )
57 {
58 // pCallStack: ret, [return ptr], this, params
59 char * pTopStack = reinterpret_cast<char *>(pCallStack + 0);
60 char * pCppStack = pTopStack;
61
62#ifdef __ARM_PCS_VFP
63 int dc = 0;
64 char * pFloatArgs = reinterpret_cast<char *>(pCppStack - 64);
65#endif
66 // return
67 typelib_TypeDescription * pReturnTypeDescr = nullptr;
68 if (pReturnTypeRef)
69 TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
70
71 void * pUnoReturn = nullptr;
72 // complex return ptr: if != 0 && != pUnoReturn, reconversion need
73 void * pCppReturn = nullptr;
74
75 if (pReturnTypeDescr)
76 {
77 if (!arm::return_in_hidden_param(pReturnTypeRef))
78 pUnoReturn = pRegisterReturn; // direct way for simple types
79 else // complex return via ptr (pCppReturn)
80 {
81 pCppReturn = *reinterpret_cast<void **>(pCppStack);
82 pCppStack += sizeof(void *);
83
85 pReturnTypeDescr )
86 ? alloca( pReturnTypeDescr->nSize )
87 : pCppReturn); // direct way
88 }
89 }
90 // pop this
91 pCppStack += sizeof( void* );
92
93 // stack space
94 static_assert(sizeof(void *) == sizeof(sal_Int32),
95 "### unexpected size!");
96 // parameters
97 void ** pUnoArgs = static_cast<void **>(alloca( 4 * sizeof(void *) * nParams ));
98 void ** pCppArgs = pUnoArgs + nParams;
99 // indices of values this have to be converted (interface conversion
100 // cpp<=>uno)
101 sal_Int32 * pTempIndices = reinterpret_cast<sal_Int32 *>(pUnoArgs + (2 * nParams));
102 // type descriptions for reconversions
103 typelib_TypeDescription ** ppTempParamTypeDescr =
104 reinterpret_cast<typelib_TypeDescription **>(pUnoArgs + (3 * nParams));
105
106 sal_Int32 nTempIndices = 0;
107
108 for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
109 {
110 const typelib_MethodParameter & rParam = pParams[nPos];
111 typelib_TypeDescription * pParamTypeDescr = nullptr;
112 TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
113
114 if (!rParam.bOut &&
116 {
117#ifdef __ARM_EABI__
118 switch (pParamTypeDescr->eTypeClass)
119 {
120 case typelib_TypeClass_HYPER:
121 case typelib_TypeClass_UNSIGNED_HYPER:
122#ifndef __ARM_PCS_VFP
123 case typelib_TypeClass_DOUBLE:
124#endif
125 if ((pCppStack - pTopStack) % 8) pCppStack+=sizeof(sal_Int32); //align to 8
126 break;
127 default:
128 break;
129 }
130#endif
131
132// For armhf we get the floating point arguments from a different area of the stack
133#ifdef __ARM_PCS_VFP
134 if (pParamTypeDescr->eTypeClass == typelib_TypeClass_FLOAT)
135 {
136 pCppArgs[nPos] = pUnoArgs[nPos] = pFloatArgs;
137 pFloatArgs += sizeof(float);
138 } else
139 if (pParamTypeDescr->eTypeClass == typelib_TypeClass_DOUBLE)
140 {
141 if ((pFloatArgs - pTopStack) % 8) pFloatArgs+=sizeof(float); //align to 8
142 pCppArgs[nPos] = pUnoArgs[nPos] = pFloatArgs;
143 pFloatArgs += sizeof(double);
144 if (++dc == arm::MAX_FPR_REGS) {
145 if (pCppStack - pTopStack < 16)
146 pCppStack = pTopStack + 16;
147 pFloatArgs = pCppStack;
148 }
149 } else
150#endif
151 pCppArgs[nPos] = pUnoArgs[nPos] = pCppStack;
152
153 switch (pParamTypeDescr->eTypeClass)
154 {
155 case typelib_TypeClass_HYPER:
156 case typelib_TypeClass_UNSIGNED_HYPER:
157#ifndef __ARM_PCS_VFP
158 case typelib_TypeClass_DOUBLE:
159#endif
160 pCppStack += sizeof(sal_Int32); // extra long
161 break;
162 default:
163 break;
164 }
165 // no longer needed
166 TYPELIB_DANGER_RELEASE( pParamTypeDescr );
167 }
168 else // ptr to complex value | ref
169 {
170 pCppArgs[nPos] = *reinterpret_cast<void **>(pCppStack);
171
172 if (! rParam.bIn) // is pure out
173 {
174 // uno out is unconstructed mem!
175 pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
176 pTempIndices[nTempIndices] = nPos;
177 // will be released at reconversion
178 ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
179 }
180 // is in/inout
182 pParamTypeDescr ))
183 {
184 uno_copyAndConvertData( pUnoArgs[nPos] =
185 alloca( pParamTypeDescr->nSize ),
186 *reinterpret_cast<void **>(pCppStack), pParamTypeDescr,
187 pThis->getBridge()->getCpp2Uno() );
188 pTempIndices[nTempIndices] = nPos; // has to be reconverted
189 // will be released at reconversion
190 ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
191 }
192 else // direct way
193 {
194 pUnoArgs[nPos] = *reinterpret_cast<void **>(pCppStack);
195 // no longer needed
196 TYPELIB_DANGER_RELEASE( pParamTypeDescr );
197 }
198 }
199#ifdef __ARM_PCS_VFP
200 // use the stack for output parameters or non floating point values
201 if (rParam.bOut ||
202 ((pParamTypeDescr->eTypeClass != typelib_TypeClass_DOUBLE)
203 && (pParamTypeDescr->eTypeClass != typelib_TypeClass_FLOAT))
204 )
205#endif
206 pCppStack += sizeof(sal_Int32); // standard parameter length
207 }
208
209 // ExceptionHolder
210 uno_Any aUnoExc; // Any will be constructed by callee
211 uno_Any * pUnoExc = &aUnoExc;
212
213 // invoke uno dispatch call
214 (*pThis->getUnoI()->pDispatcher)(
215 pThis->getUnoI(), pMemberTypeDescr, pUnoReturn, pUnoArgs, &pUnoExc );
216
217 // in case an exception occurred...
218 if (pUnoExc)
219 {
220 // destruct temporary in/inout params
221 for ( ; nTempIndices--; )
222 {
223 sal_Int32 nIndex = pTempIndices[nTempIndices];
224
225 if (pParams[nIndex].bIn) // is in/inout => was constructed
226 uno_destructData( pUnoArgs[nIndex],
227 ppTempParamTypeDescr[nTempIndices], nullptr );
228 TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
229 }
230 if (pReturnTypeDescr)
231 TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
232
234 pThis->getBridge()->getUno2Cpp() ); // has to destruct the any
235 // is here for dummy
236 return typelib_TypeClass_VOID;
237 }
238 else // else no exception occurred...
239 {
240 // temporary params
241 for ( ; nTempIndices--; )
242 {
243 sal_Int32 nIndex = pTempIndices[nTempIndices];
244 typelib_TypeDescription * pParamTypeDescr =
245 ppTempParamTypeDescr[nTempIndices];
246
247 if (pParams[nIndex].bOut) // inout/out
248 {
249 // convert and assign
250 uno_destructData( pCppArgs[nIndex], pParamTypeDescr,
251 cpp_release );
252 uno_copyAndConvertData( pCppArgs[nIndex], pUnoArgs[nIndex],
253 pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
254 }
255 // destroy temp uno param
256 uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, nullptr );
257
258 TYPELIB_DANGER_RELEASE( pParamTypeDescr );
259 }
260 // return
261 if (pCppReturn) // has complex return
262 {
263 if (pUnoReturn != pCppReturn) // needs reconversion
264 {
265 uno_copyAndConvertData( pCppReturn, pUnoReturn,
266 pReturnTypeDescr, pThis->getBridge()->getUno2Cpp() );
267 // destroy temp uno return
268 uno_destructData( pUnoReturn, pReturnTypeDescr, nullptr );
269 }
270 // complex return ptr is set to eax
271 *reinterpret_cast<void **>(pRegisterReturn) = pCppReturn;
272 }
273 if (pReturnTypeDescr)
274 {
275 typelib_TypeClass eRet = pReturnTypeDescr->eTypeClass;
276 TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
277 return eRet;
278 }
279 else
280 return typelib_TypeClass_VOID;
281 }
282 }
283
284
285 typelib_TypeClass cpp_mediate(
286 sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset,
287 void ** pCallStack,
288 sal_Int64 * pRegisterReturn /* space for register return */ )
289 {
290 static_assert(sizeof(sal_Int32)==sizeof(void *), "### unexpected!");
291
292 // pCallStack: [ret *], this, params
293 // _this_ ptr is patched cppu_XInterfaceProxy object
294 void *pThis;
295 if( nFunctionIndex & 0x80000000 )
296 {
297 nFunctionIndex &= 0x7fffffff;
298 pThis = pCallStack[1];
299 }
300 else
301 {
302 pThis = pCallStack[0];
303 }
304
305 pThis = static_cast< char * >(pThis) - nVtableOffset;
308 pThis);
309
310 typelib_InterfaceTypeDescription * pTypeDescr = pCppI->getTypeDescr();
311
312 if (nFunctionIndex >= pTypeDescr->nMapFunctionIndexToMemberIndex)
313 {
314 SAL_WARN(
315 "bridges",
316 "illegal " << OUString::unacquired(&pTypeDescr->aBase.pTypeName)
317 << " vtable index " << nFunctionIndex << "/"
318 << pTypeDescr->nMapFunctionIndexToMemberIndex);
319 throw RuntimeException(
320 ("illegal " + OUString::unacquired(&pTypeDescr->aBase.pTypeName)
321 + " vtable index " + OUString::number(nFunctionIndex) + "/"
322 + OUString::number(pTypeDescr->nMapFunctionIndexToMemberIndex)),
323 reinterpret_cast<XInterface *>(pCppI));
324 }
325
326 // determine called method
327 assert(nFunctionIndex < pTypeDescr->nMapFunctionIndexToMemberIndex);
328 sal_Int32 nMemberPos =
329 pTypeDescr->pMapFunctionIndexToMemberIndex[nFunctionIndex];
330 assert(nMemberPos < pTypeDescr->nAllMembers);
331
332 TypeDescription aMemberDescr( pTypeDescr->ppAllMembers[nMemberPos] );
333
334 typelib_TypeClass eRet;
335 switch (aMemberDescr.get()->eTypeClass)
336 {
337 case typelib_TypeClass_INTERFACE_ATTRIBUTE:
338 {
339 if (pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos] ==
340 nFunctionIndex)
341 {
342 // is GET method
343 eRet = cpp2uno_call(
344 pCppI, aMemberDescr.get(),
345 reinterpret_cast<typelib_InterfaceAttributeTypeDescription *>(aMemberDescr.get())->pAttributeTypeRef,
346 0, nullptr, // no params
347 pCallStack, pRegisterReturn );
348 }
349 else
350 {
351 // is SET method
352 typelib_MethodParameter aParam;
353 aParam.pTypeRef =
354 reinterpret_cast<typelib_InterfaceAttributeTypeDescription *>(aMemberDescr.get())->pAttributeTypeRef;
355 aParam.bIn = true;
356 aParam.bOut = false;
357
358 eRet = cpp2uno_call(
359 pCppI, aMemberDescr.get(),
360 nullptr, // indicates void return
361 1, &aParam,
362 pCallStack, pRegisterReturn );
363 }
364 break;
365 }
366 case typelib_TypeClass_INTERFACE_METHOD:
367 {
368 // is METHOD
369 switch (nFunctionIndex)
370 {
371 case 1: // acquire()
372 pCppI->acquireProxy(); // non virtual call!
373 eRet = typelib_TypeClass_VOID;
374 break;
375 case 2: // release()
376 pCppI->releaseProxy(); // non virtual call!
377 eRet = typelib_TypeClass_VOID;
378 break;
379 case 0: // queryInterface() opt
380 {
381 typelib_TypeDescription * pTD = nullptr;
382 TYPELIB_DANGER_GET(&pTD,
383 static_cast<Type *>(pCallStack[2])->getTypeLibType());
384 if (pTD)
385 {
386 XInterface * pInterface = nullptr;
387 (*pCppI->getBridge()->getCppEnv()->getRegisteredInterface)(
388 pCppI->getBridge()->getCppEnv(),
389 reinterpret_cast<void **>(&pInterface), pCppI->getOid().pData,
390 reinterpret_cast<typelib_InterfaceTypeDescription *>(pTD) );
391
392 if (pInterface)
393 {
394 ::uno_any_construct(
395 static_cast< uno_Any * >( pCallStack[0] ),
396 &pInterface, pTD, cpp_acquire );
397 pInterface->release();
398 TYPELIB_DANGER_RELEASE( pTD );
399 *reinterpret_cast<void **>(pRegisterReturn) = pCallStack[0];
400 eRet = typelib_TypeClass_ANY;
401 break;
402 }
403 TYPELIB_DANGER_RELEASE( pTD );
404 }
405 } [[fallthrough]]; // else perform queryInterface()
406 default:
407 eRet = cpp2uno_call(
408 pCppI, aMemberDescr.get(),
409 reinterpret_cast<typelib_InterfaceMethodTypeDescription *>(aMemberDescr.get())->pReturnTypeRef,
410 reinterpret_cast<typelib_InterfaceMethodTypeDescription *>(aMemberDescr.get())->nParams,
411 reinterpret_cast<typelib_InterfaceMethodTypeDescription *>(aMemberDescr.get())->pParams,
412 pCallStack, pRegisterReturn );
413 }
414 break;
415 }
416 default:
417 {
418 throw RuntimeException( "no member description found!", reinterpret_cast<XInterface *>(pCppI) );
419 }
420 }
421
422 return eRet;
423 }
424}
425
431sal_Int64 cpp_vtable_call( long *pFunctionAndOffset,
432 void **pCallStack )
433{
434 sal_Int64 nRegReturn;
435 typelib_TypeClass aType = cpp_mediate( pFunctionAndOffset[0], pFunctionAndOffset[1], pCallStack,
436 &nRegReturn );
437
438 switch( aType )
439 {
440 case typelib_TypeClass_BOOLEAN:
441 case typelib_TypeClass_BYTE:
442 nRegReturn = static_cast<unsigned long>(*reinterpret_cast<unsigned char *>(&nRegReturn));
443 break;
444 case typelib_TypeClass_CHAR:
445 case typelib_TypeClass_UNSIGNED_SHORT:
446 case typelib_TypeClass_SHORT:
447 nRegReturn = static_cast<unsigned long>(*reinterpret_cast<unsigned short *>(&nRegReturn));
448 break;
449 case typelib_TypeClass_ENUM:
450 case typelib_TypeClass_UNSIGNED_LONG:
451 case typelib_TypeClass_LONG:
452 nRegReturn = static_cast<unsigned long>(*reinterpret_cast<unsigned int *>(&nRegReturn));
453 break;
454 case typelib_TypeClass_VOID:
455 default:
456 break;
457 }
458
459 return nRegReturn;
460}
461
462namespace
463{
464 const int codeSnippetSize = 20;
465
466 unsigned char *codeSnippet(unsigned char* code, sal_Int32 functionIndex,
467 sal_Int32 vtableOffset, bool bHasHiddenParam)
468 {
469 if (bHasHiddenParam)
470 functionIndex |= 0x80000000;
471
472 unsigned long * p = reinterpret_cast<unsigned long *>(code);
473
474 // ARM (not thumb) mode instructions
475 // mov ip, pc
476 *p++ = 0xE1A0C00F;
477 // ldr pc, [pc, #4]
478 *p++ = 0xE59FF004;
479 *p++ = static_cast<unsigned long>(functionIndex);
480 *p++ = static_cast<unsigned long>(vtableOffset);
481 *p++ = reinterpret_cast<unsigned long>(privateSnippetExecutor);
482
483 return code + codeSnippetSize;
484 }
485}
486
488
491{
492 return static_cast< Slot * >(block) + 2;
493}
494
496 sal_Int32 slotCount)
497{
498 return (slotCount + 2) * sizeof (Slot) + slotCount * codeSnippetSize;
499}
500
503 void * block, sal_Int32 slotCount, sal_Int32,
504 typelib_InterfaceTypeDescription *)
505{
506 Slot * slots = mapBlockToVtable(block);
507 slots[-2].fn = nullptr;
508 slots[-1].fn = nullptr;
509 return slots + slotCount;
510}
511
513 Slot ** slots, unsigned char * code,
514#ifdef USE_DOUBLE_MMAP
515 sal_PtrDiff writetoexecdiff,
516#endif
517 typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,
518 sal_Int32 functionCount, sal_Int32 vtableOffset)
519{
520#ifndef USE_DOUBLE_MMAP
521 const sal_PtrDiff writetoexecdiff = 0;
522#endif
523 (*slots) -= functionCount;
524 Slot * s = *slots;
525 for (sal_Int32 i = 0; i < type->nMembers; ++i)
526 {
527 typelib_TypeDescription * member = nullptr;
528 TYPELIB_DANGER_GET(&member, type->ppMembers[i]);
529 assert(member != 0);
530 switch (member->eTypeClass)
531 {
532 case typelib_TypeClass_INTERFACE_ATTRIBUTE:
533 {
534 typelib_InterfaceAttributeTypeDescription *pAttrTD =
535 reinterpret_cast<typelib_InterfaceAttributeTypeDescription *>( member );
536
537 // Getter:
538 (s++)->fn = code + writetoexecdiff;
540 code, functionOffset++, vtableOffset,
541 arm::return_in_hidden_param( pAttrTD->pAttributeTypeRef ));
542
543 // Setter:
544 if (!pAttrTD->bReadOnly)
545 {
546 (s++)->fn = code + writetoexecdiff;
548 code, functionOffset++, vtableOffset, false);
549 }
550 break;
551 }
552 case typelib_TypeClass_INTERFACE_METHOD:
553 {
554 (s++)->fn = code + writetoexecdiff;
555
556 typelib_InterfaceMethodTypeDescription *pMethodTD =
557 reinterpret_cast<
558 typelib_InterfaceMethodTypeDescription * >(member);
559
560 code = codeSnippet(code, functionOffset++, vtableOffset,
561 arm::return_in_hidden_param(pMethodTD->pReturnTypeRef));
562 break;
563 }
564 default:
565 assert(false);
566 break;
567 }
568 TYPELIB_DANGER_RELEASE(member);
569 }
570 return code;
571}
572
574 unsigned char const *beg, unsigned char const *end)
575{
576#ifndef ANDROID
577 static void (*clear_cache)(unsigned char const*, unsigned char const*)
578 = reinterpret_cast<void (*)(unsigned char const*, unsigned char const*)>
579 (dlsym(RTLD_DEFAULT, "__clear_cache"));
580 (*clear_cache)(beg, end);
581#else
582 cacheflush((long) beg, (long) end, 0);
583#endif
584}
585
586/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
uno_Mapping * getUno2Cpp()
Definition: bridge.hxx:73
uno_ExtEnvironment * getCppEnv()
Definition: bridge.hxx:69
uno_Mapping * getCpp2Uno()
Definition: bridge.hxx:72
A cpp proxy wrapping a uno interface.
static CppInterfaceProxy * castInterfaceToProxy(void *pInterface)
typelib_InterfaceTypeDescription * getTypeDescr()
static Slot * mapBlockToVtable(void *block)
Given a pointer to a block, turn it into a vtable pointer.
static void flushCode(unsigned char const *begin, unsigned char const *end)
Flush all the generated code snippets of a vtable, on platforms that require it.
static unsigned char * addLocalFunctions(Slot **slots, unsigned char *code, sal_PtrDiff writetoexecdiff, typelib_InterfaceTypeDescription const *type, sal_Int32 functionOffset, sal_Int32 functionCount, sal_Int32 vtableOffset)
Fill the vtable slots corresponding to all local (i.e., not inherited) functions of a given interface...
static Slot * initializeBlock(void *block, sal_Int32 slotCount, sal_Int32 vtableNumber, typelib_InterfaceTypeDescription *type)
Initialize a raw vtable block.
static std::size_t getBlockSize(sal_Int32 slotCount)
Calculate the size of a raw vtable block.
void SAL_CALL uno_destructData(void *pValue, typelib_TypeDescription *pTypeDescr, uno_ReleaseFunc release) SAL_THROW_EXTERN_C()
void SAL_CALL uno_copyAndConvertData(void *pDest, void *pSource, typelib_TypeDescription *pTypeDescr, uno_Mapping *mapping) SAL_THROW_EXTERN_C()
sal_Int64 cpp_vtable_call(long *pFunctionAndOffset, void **pCallStack)
is called on incoming vtable calls (called by asm snippets)
void(* privateSnippetExecutor)()
const int codeSnippetSize
static unsigned char * codeSnippet(unsigned char *code, sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset, bool bHasHiddenParam)
static int cpp2uno_call(bridges::cpp_uno::shared::CppInterfaceProxy *pThis, const typelib_TypeDescription *pMemberTypeDescr, typelib_TypeDescriptionReference *pReturnTypeRef, sal_Int32 nParams, typelib_MethodParameter *pParams, void **gpreg, void **fpreg, void **ovrflw, sal_uInt64 *pRegisterReturn)
sal_Int32 nIndex
void * p
sal_uInt16 nPos
#define SAL_WARN(area, stream)
struct _typelib_TypeDescription typelib_TypeDescription
Definition: msvc/except.hxx:52
struct _uno_Any uno_Any
Definition: msvc/except.hxx:31
typelib_TypeClass __cdecl cpp_mediate(void **pCallStack, const sal_Int32 nFunctionIndex, const sal_Int32 nVtableOffset, sal_Int64 *const pRegisterReturn)
void raiseException(uno_Any *pUnoExc, uno_Mapping *pUno2Cpp)
@ MAX_FPR_REGS
bool return_in_hidden_param(typelib_TypeDescriptionReference *pTypeRef)
bool isSimpleType(typelib_TypeClass typeClass)
Determines whether a type is a "simple" type (VOID, BOOLEAN, BYTE, SHORT, UNSIGNED SHORT,...
Definition: types.cxx:28
bool relatesToInterfaceType(typelib_TypeDescription const *type)
Determines whether a type relates to an interface type (is itself an interface type,...
Definition: types.cxx:41
Type
int i
end
sal_Unicode code
ResultType type
#define USE_DOUBLE_MMAP