LibreOffice Module bridges (master)  1
gcc3_ios/uno2cpp.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 #ifdef __arm64
21 
22 #include <sal/config.h>
23 
24 #include <exception>
25 #include <typeinfo>
26 
27 #include <com/sun/star/uno/Exception.hpp>
28 #include <com/sun/star/uno/RuntimeException.hpp>
30 
31 #include "bridge.hxx"
32 #include "types.hxx"
33 #include "unointerfaceproxy.hxx"
34 #include "vtables.hxx"
35 
36 #include "share.hxx"
37 
38 using namespace ::com::sun::star::uno;
39 
40 namespace arm
41 {
42  bool is_hfa_struct(const typelib_TypeDescription * type)
43  {
44  const typelib_CompoundTypeDescription * p
45  = reinterpret_cast< const typelib_CompoundTypeDescription * >(type);
46  if (p->nMembers >= 4)
47  return false;
48  for (sal_Int32 i = 0; i < p->nMembers; ++i)
49  {
50  if ((p->ppTypeRefs[i]->eTypeClass != typelib_TypeClass_FLOAT &&
51  p->ppTypeRefs[i]->eTypeClass != typelib_TypeClass_DOUBLE) ||
52  p->ppTypeRefs[i]->eTypeClass != p->ppTypeRefs[0]->eTypeClass)
53  return false;
54  }
55  return true;
56  }
57 
58  bool return_in_x8( typelib_TypeDescriptionReference *pTypeRef )
59  {
61  return false;
62  else if (pTypeRef->eTypeClass == typelib_TypeClass_STRUCT || pTypeRef->eTypeClass == typelib_TypeClass_EXCEPTION)
63  {
64  typelib_TypeDescription * pTypeDescr = 0;
65  TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef );
66 
67  // A Composite Type not larger than 16 bytes is returned in x0, x1
68  bool bRet = pTypeDescr->nSize > 16;
69 
70  if (is_hfa_struct(pTypeDescr))
71  bRet = false;
72 
73  TYPELIB_DANGER_RELEASE( pTypeDescr );
74  return bRet;
75  }
76  return true;
77  }
78 }
79 
80 void MapReturn(sal_uInt64 x0, sal_uInt64 x1, double d0, typelib_TypeDescriptionReference *pReturnType, sal_uInt64 *pRegisterReturn)
81 {
82  switch( pReturnType->eTypeClass )
83  {
84  case typelib_TypeClass_HYPER:
85  case typelib_TypeClass_UNSIGNED_HYPER:
86  pRegisterReturn[1] = x1;
87  [[fallthrough]];
88  case typelib_TypeClass_LONG:
89  case typelib_TypeClass_UNSIGNED_LONG:
90  case typelib_TypeClass_ENUM:
91  case typelib_TypeClass_CHAR:
92  case typelib_TypeClass_SHORT:
93  case typelib_TypeClass_UNSIGNED_SHORT:
94  case typelib_TypeClass_BOOLEAN:
95  case typelib_TypeClass_BYTE:
96  pRegisterReturn[0] = x0;
97  break;
98  case typelib_TypeClass_FLOAT:
99  *(float*)pRegisterReturn = *(float*)&d0;
100  break;
101  case typelib_TypeClass_DOUBLE:
102  *(double*)pRegisterReturn = d0;
103  break;
104  case typelib_TypeClass_STRUCT:
105  case typelib_TypeClass_EXCEPTION:
106  if (!arm::return_in_x8(pReturnType))
107  {
108  pRegisterReturn[0] = x0;
109  pRegisterReturn[1] = x1;
110  }
111  break;
112  default:
113  break;
114  }
115 }
116 
117 namespace
118 {
119 void callVirtualMethod(
120  void *pThis,
121  sal_Int32 nVtableIndex,
122  void *pRegisterReturn,
123  typelib_TypeDescriptionReference *pReturnType,
124  sal_uInt64 *pStack,
125  int nStack,
126  sal_uInt64 *pGPR,
127  double *pFPR)
128 {
129  // never called
130  if (! pThis)
131  CPPU_CURRENT_NAMESPACE::dummy_can_throw_anything("xxx"); // address something
132 
133  if ( nStack )
134  {
135  // 16-bytes aligned
136  sal_uInt32 nStackBytes = ( ( nStack + 3 ) >> 2 ) * 16;
137  sal_uInt32 *stack = (sal_uInt32 *) alloca( nStackBytes );
138  memcpy( stack, pStack, nStackBytes );
139  }
140 
141  sal_uInt64 pMethod = *((sal_uInt64*)pThis);
142  pMethod += 8 * nVtableIndex;
143  pMethod = *((sal_uInt64 *)pMethod);
144 
145  // For value returned in registers
146  sal_uInt64 x0;
147  sal_uInt64 x1;
148  double d0;
149 
150  __asm__ __volatile__
151  (
152  // Assembly string
153  " ldp x0, x1, %[pgpr_0]\n"
154  " ldp x2, x3, %[pgpr_2]\n"
155  " ldp x4, x5, %[pgpr_4]\n"
156  " ldp x6, x7, %[pgpr_6]\n"
157  " ldr x8, %[pregisterreturn]\n"
158  " ldp d0, d1, %[pfpr_0]\n"
159  " ldp d2, d3, %[pfpr_2]\n"
160  " ldp d4, d5, %[pfpr_4]\n"
161  " ldp d6, d7, %[pfpr_6]\n"
162  " blr %[pmethod]\n"
163  " str x0, %[x0]\n"
164  " str x1, %[x1]\n"
165  " str d0, %[d0]\n"
166  // Output operands
167  : [x0]"=m" (x0), [x1]"=m" (x1), [d0]"=m" (d0)
168  // Input operands
169  : [pgpr_0]"m" (pGPR[0]),
170  [pgpr_2]"m" (pGPR[2]),
171  [pgpr_4]"m" (pGPR[4]),
172  [pgpr_6]"m" (pGPR[6]),
173  [pregisterreturn]"m" (pRegisterReturn),
174  [pfpr_0]"m" (pFPR[0]),
175  [pfpr_2]"m" (pFPR[2]),
176  [pfpr_4]"m" (pFPR[4]),
177  [pfpr_6]"m" (pFPR[6]),
178  [pmethod]"r" (pMethod)
179  // Clobbers
180  : "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", "x8", "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7"
181  );
182 
183  MapReturn(x0, x1, d0, pReturnType, (sal_uInt64 *) pRegisterReturn);
184 }
185 }
186 
187 #define INSERT_INT64( pSV, nr, pGPR, pDS ) \
188  if ( nr < arm::MAX_GPR_REGS ) \
189  pGPR[nr++] = *reinterpret_cast<sal_uInt64 *>( pSV ); \
190  else \
191  *pDS++ = *reinterpret_cast<sal_uInt64 *>( pSV );
192 
193 #define INSERT_INT32( pSV, nr, pGPR, pDS ) \
194  if ( nr < arm::MAX_GPR_REGS ) \
195  pGPR[nr++] = *reinterpret_cast<sal_uInt32 *>( pSV ); \
196  else \
197  *pDS++ = *reinterpret_cast<sal_uInt32 *>( pSV );
198 
199 #define INSERT_INT16( pSV, nr, pGPR, pDS ) \
200  if ( nr < arm::MAX_GPR_REGS ) \
201  pGPR[nr++] = *reinterpret_cast<sal_uInt16 *>( pSV ); \
202  else \
203  *pDS++ = *reinterpret_cast<sal_uInt16 *>( pSV );
204 
205 #define INSERT_INT8( pSV, nr, pGPR, pDS ) \
206  if ( nr < arm::MAX_GPR_REGS ) \
207  pGPR[nr++] = *reinterpret_cast<sal_uInt8 *>( pSV ); \
208  else \
209  *pDS++ = *reinterpret_cast<sal_uInt8 *>( pSV );
210 
211 #define INSERT_DOUBLE( pSV, nr, pFPR, pDS ) \
212  if ( nr < arm::MAX_FPR_REGS ) \
213  pFPR[nr++] = *reinterpret_cast<double *>( pSV ); \
214  else \
215  *pDS++ = *reinterpret_cast<double *>( pSV );
216 
217 #define INSERT_FLOAT( pSV, nr, pFPR, pDS ) \
218  INSERT_DOUBLE( pSV, nr, pGPR, pDS )
219 
220 namespace {
221 static void cpp_call(
224  typelib_TypeDescriptionReference * pReturnTypeRef,
225  sal_Int32 nParams, typelib_MethodParameter * pParams,
226  void * pUnoReturn, void * pUnoArgs[], uno_Any ** ppUnoExc )
227 {
228  // max space for: values|ptr ...
229  sal_uInt64 * pStack = (sal_uInt64 *)alloca( (nParams+2) * sizeof(sal_Int64) );
230  sal_uInt64 * pStackStart = pStack;
231 
232  sal_uInt64 pGPR[arm::MAX_GPR_REGS];
233  int nGPR = 0;
234 
235  // storage and counter for SIMD/FP registers
236  double pFPR[arm::MAX_FPR_REGS];
237  int nFPR = 0;
238 
239  // return
240  typelib_TypeDescription * pReturnTypeDescr = 0;
241  TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
242  assert( pReturnTypeDescr);
243 
244  void * pCppReturn = 0; // if != 0 && != pUnoReturn, needs reconversion
245 
246  if (pReturnTypeDescr)
247  {
248  if (!arm::return_in_x8( pReturnTypeRef ) )
249  pCppReturn = pUnoReturn; // direct way for simple types
250  else
251  {
252  // complex return via x8
253  pCppReturn = (bridges::cpp_uno::shared::relatesToInterfaceType( pReturnTypeDescr )
254  ? alloca( pReturnTypeDescr->nSize )
255  : pUnoReturn); // direct way
256  }
257  }
258  // push this
259  void * pAdjustedThisPtr = reinterpret_cast< void ** >(pThis->getCppI())
260  + aVtableSlot.offset;
261  INSERT_INT64( &pAdjustedThisPtr, nGPR, pGPR, pStack );
262 
263  // stack space
264  // args
265  void ** pCppArgs = (void **)alloca( sizeof(void *) * nParams );
266 
267  // indices of values this have to be converted (interface conversion cpp<=>uno)
268  int * pTempIndices = (int *)alloca( sizeof(int) * nParams );
269 
270  // type descriptions for reconversions
271  typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)alloca( sizeof(void *) * nParams );
272 
273  sal_Int32 nTempIndices = 0;
274 
275  for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
276  {
277  const typelib_MethodParameter & rParam = pParams[nPos];
278  typelib_TypeDescription * pParamTypeDescr = 0;
279  TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
280 
281  if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
282  {
283  uno_copyAndConvertData( pCppArgs[nPos] = alloca(8), pUnoArgs[nPos],
284  pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
285 
286  switch (pParamTypeDescr->eTypeClass)
287  {
288  case typelib_TypeClass_HYPER:
289  case typelib_TypeClass_UNSIGNED_HYPER:
290  INSERT_INT64( pCppArgs[nPos], nGPR, pGPR, pStack );
291  break;
292  case typelib_TypeClass_LONG:
293  case typelib_TypeClass_UNSIGNED_LONG:
294  case typelib_TypeClass_ENUM:
295  INSERT_INT32( pCppArgs[nPos], nGPR, pGPR, pStack );
296  break;
297  case typelib_TypeClass_SHORT:
298  case typelib_TypeClass_CHAR:
299  case typelib_TypeClass_UNSIGNED_SHORT:
300  INSERT_INT16( pCppArgs[nPos], nGPR, pGPR, pStack );
301  break;
302  case typelib_TypeClass_BOOLEAN:
303  case typelib_TypeClass_BYTE:
304  INSERT_INT8( pCppArgs[nPos], nGPR, pGPR, pStack );
305  break;
306  case typelib_TypeClass_FLOAT:
307  INSERT_FLOAT( pCppArgs[nPos], nFPR, pFPR, pStack );
308  break;
309  case typelib_TypeClass_DOUBLE:
310  INSERT_DOUBLE( pCppArgs[nPos], nFPR, pFPR, pStack );
311  break;
312  default:
313  break;
314  }
315  // no longer needed
316  TYPELIB_DANGER_RELEASE( pParamTypeDescr );
317  }
318  else // ptr to complex value | ref
319  {
320  if (! rParam.bIn) // is pure out
321  {
322  // cpp out is constructed mem, uno out is not!
324  pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
325  pParamTypeDescr );
326  pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
327  // will be released at reconversion
328  ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
329  }
330  // is in/inout
331  else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
332  {
334  pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
335  pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
336 
337  pTempIndices[nTempIndices] = nPos; // has to be reconverted
338  // will be released at reconversion
339  ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
340  }
341  else // direct way
342  {
343  pCppArgs[nPos] = pUnoArgs[nPos];
344  // no longer needed
345  TYPELIB_DANGER_RELEASE( pParamTypeDescr );
346  }
347  INSERT_INT64( &(pCppArgs[nPos]), nGPR, pGPR, pStack );
348  }
349  }
350 
351  assert( nGPR <= arm::MAX_GPR_REGS );
352  assert( nFPR <= arm::MAX_FPR_REGS );
353 
354  try
355  {
356  try {
358  pAdjustedThisPtr, aVtableSlot.index,
359  pCppReturn, pReturnTypeRef,
360  pStackStart,
361  (pStack - pStackStart),
362  pGPR,
363  pFPR);
364  } catch (css::uno::Exception &) {
365  throw;
366  } catch (std::exception & e) {
367  throw css::uno::RuntimeException(
368  "C++ code threw " + o3tl::runtimeToOUString(typeid(e).name()) + ": "
369  + o3tl::runtimeToOUString(e.what()));
370  } catch (...) {
371  throw css::uno::RuntimeException("C++ code threw unknown exception");
372  }
373 
374  // NO exception occurred...
375  *ppUnoExc = 0;
376 
377  // reconvert temporary params
378  for ( ; nTempIndices--; )
379  {
380  sal_Int32 nIndex = pTempIndices[nTempIndices];
381  typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
382 
383  if (pParams[nIndex].bIn)
384  {
385  if (pParams[nIndex].bOut) // inout
386  {
387  uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 ); // destroy uno value
388  uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
389  pThis->getBridge()->getCpp2Uno() );
390  }
391  }
392  else // pure out
393  {
394  uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
395  pThis->getBridge()->getCpp2Uno() );
396  }
397  // destroy temp cpp param => cpp: every param was constructed
398  uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
399 
400  TYPELIB_DANGER_RELEASE( pParamTypeDescr );
401  }
402  // return value
403  if (pCppReturn && pUnoReturn != pCppReturn)
404  {
405  uno_copyAndConvertData( pUnoReturn, pCppReturn, pReturnTypeDescr,
406  pThis->getBridge()->getCpp2Uno() );
407  uno_destructData( pCppReturn, pReturnTypeDescr, cpp_release );
408  }
409  }
410  catch (...)
411  {
412  // fill uno exception
414 
415  // temporary params
416  for ( ; nTempIndices--; )
417  {
418  sal_Int32 nIndex = pTempIndices[nTempIndices];
419  // destroy temp cpp param => cpp: every param was constructed
420  uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
421  TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
422  }
423 
424  // return type
425  if (pReturnTypeDescr)
426  TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
427  }
428 }
429 }
430 
431 namespace bridges::cpp_uno::shared {
432 
434  uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr,
435  void * pReturn, void * pArgs[], uno_Any ** ppException )
436 {
437  // is my surrogate
439  = static_cast< bridges::cpp_uno::shared::UnoInterfaceProxy * >(pUnoI);
440 #if OSL_DEBUG_LEVEL > 0
441  typelib_InterfaceTypeDescription * pTypeDescr = pThis->pTypeDescr;
442 #endif
443 
444  switch (pMemberDescr->eTypeClass)
445  {
446  case typelib_TypeClass_INTERFACE_ATTRIBUTE:
447  {
448 #if OSL_DEBUG_LEVEL > 0
449  // determine vtable call index
450  sal_Int32 nMemberPos = ((typelib_InterfaceMemberTypeDescription *)pMemberDescr)->nPosition;
451  assert( nMemberPos < pTypeDescr->nAllMembers && "### member pos out of range!");
452 #endif
453 
454  VtableSlot aVtableSlot(
456  reinterpret_cast<typelib_InterfaceAttributeTypeDescription const *>
457  (pMemberDescr)));
458 
459  if (pReturn)
460  {
461  // dependent dispatch
462  cpp_call(
463  pThis, aVtableSlot,
464  ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef,
465  0, 0, // no params
466  pReturn, pArgs, ppException );
467  }
468  else
469  {
470  // is SET
471  typelib_MethodParameter aParam;
472  aParam.pTypeRef =
473  ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef;
474  aParam.bIn = sal_True;
475  aParam.bOut = sal_False;
476 
477  typelib_TypeDescriptionReference * pReturnTypeRef = 0;
478  OUString aVoidName("void");
480  &pReturnTypeRef, typelib_TypeClass_VOID, aVoidName.pData );
481 
482  // dependent dispatch
483  aVtableSlot.index += 1;
484  cpp_call(
485  pThis, aVtableSlot, // get, then set method
486  pReturnTypeRef,
487  1, &aParam,
488  pReturn, pArgs, ppException );
489 
491  }
492 
493  break;
494  }
495  case typelib_TypeClass_INTERFACE_METHOD:
496  {
497 #if OSL_DEBUG_LEVEL > 0
498  // determine vtable call index
499  sal_Int32 nMemberPos = ((typelib_InterfaceMemberTypeDescription *)pMemberDescr)->nPosition;
500  assert(nMemberPos < pTypeDescr->nAllMembers && "### member pos out of range!");
501 #endif
502 
503  VtableSlot aVtableSlot(
505  reinterpret_cast<typelib_InterfaceMethodTypeDescription const *>
506  (pMemberDescr)));
507 
508  switch (aVtableSlot.index)
509  {
510  // standard calls
511  case 1: // acquire uno interface
512  (*pUnoI->acquire)( pUnoI );
513  *ppException = 0;
514  break;
515  case 2: // release uno interface
516  (*pUnoI->release)( pUnoI );
517  *ppException = 0;
518  break;
519  case 0: // queryInterface() opt
520  {
521  typelib_TypeDescription * pTD = 0;
522  TYPELIB_DANGER_GET( &pTD, reinterpret_cast< Type * >( pArgs[0] )->getTypeLibType() );
523  if (pTD)
524  {
525  uno_Interface * pInterface = 0;
526  (*pThis->getBridge()->getUnoEnv()->getRegisteredInterface)(
527  pThis->getBridge()->getUnoEnv(),
528  (void **)&pInterface, pThis->oid.pData, (typelib_InterfaceTypeDescription *)pTD );
529 
530  if (pInterface)
531  {
532  ::uno_any_construct(
533  reinterpret_cast< uno_Any * >( pReturn ),
534  &pInterface, pTD, 0 );
535  (*pInterface->release)( pInterface );
536  TYPELIB_DANGER_RELEASE( pTD );
537  *ppException = 0;
538  break;
539  }
540  TYPELIB_DANGER_RELEASE( pTD );
541  }
542  } // else perform queryInterface()
543  [[fallthrough]];
544  default:
545  // dependent dispatch
546  cpp_call(
547  pThis, aVtableSlot,
548  ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pReturnTypeRef,
549  ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->nParams,
550  ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pParams,
551  pReturn, pArgs, ppException );
552  }
553  break;
554  }
555  default:
556  {
557  ::com::sun::star::uno::RuntimeException aExc(
558  "illegal member type description!",
560 
561  Type const & rExcType = cppu::UnoType<decltype(aExc)>::get();
562  // binary identical null reference
563  ::uno_type_any_construct( *ppException, &aExc, rExcType.getTypeLibType(), 0 );
564  }
565  }
566 }
567 
568 }
569 
570 #endif
571 
572 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Type
sal_Int32 nIndex
void SAL_CALL uno_destructData(void *pValue, typelib_TypeDescription *pTypeDescr, uno_ReleaseFunc release) SAL_THROW_EXTERN_C()
Represents a vtable slot of a C++ class.
Definition: vtables.hxx:59
void fillUnoException(uno_Any *pExc, uno_Mapping *pCpp2Uno)
bool isSimpleType(typelib_TypeClass typeClass)
Determines whether a type is a "simple" type (VOID, BOOLEAN, BYTE, SHORT, UNSIGNED SHORT...
Definition: types.cxx:28
#define INSERT_INT32(pSV, pDS)
sal_Int32 index
The index within the vtable.
Definition: vtables.hxx:76
A uno proxy wrapping a cpp interface.
void callVirtualMethod(void *pThis, sal_uInt32 nVtableIndex, void *pRegisterReturn, typelib_TypeDescription *pReturnTypeDescr, bool bRegisterReturn, sal_uInt32 *pStack, sal_uInt32 nStack, sal_uInt32 *pGPR, double *pFPR) __attribute__((noinline))
bool relatesToInterfaceType(typelib_TypeDescription const *type)
Determines whether a type relates to an interface type (is itself an interface type, or might contain entities of interface type).
Definition: types.cxx:41
void unoInterfaceProxyDispatch(uno_Interface *pUnoI, const typelib_TypeDescription *pMemberDescr, void *pReturn, void *pArgs[], uno_Any **ppException)
bool return_in_x8(typelib_TypeDescriptionReference *pTypeRef)
uno_ExtEnvironment * getUnoEnv()
Definition: bridge.hxx:70
struct _uno_Any uno_Any
Definition: msvc/except.hxx:31
uno_Mapping * getUno2Cpp()
Definition: bridge.hxx:73
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)
#define INSERT_INT8(pSV, pDS)
sal_Int32 offset
The offset of the vtable.
Definition: vtables.hxx:68
int i
typelib_InterfaceTypeDescription * pTypeDescr
void SAL_CALL uno_constructData(void *pMem, typelib_TypeDescription *pTypeDescr) SAL_THROW_EXTERN_C()
#define sal_True
void SAL_CALL uno_copyAndConvertData(void *pDest, void *pSource, typelib_TypeDescription *pTypeDescr, uno_Mapping *mapping) SAL_THROW_EXTERN_C()
void SAL_CALL typelib_typedescriptionreference_release(typelib_TypeDescriptionReference *pRef) SAL_THROW_EXTERN_C()
#define INSERT_INT64(pSV, pDS)
struct _typelib_TypeDescription typelib_TypeDescription
Definition: msvc/except.hxx:52
uno_Mapping * getCpp2Uno()
Definition: bridge.hxx:72
void MapReturn(long r0, typelib_TypeClass eTypeClass, sal_uInt64 *pRegisterReturn)
VtableSlot getVtableSlot(typelib_InterfaceAttributeTypeDescription const *ifcMember)
Calculates the vtable slot associated with an interface attribute member.
Definition: vtables.cxx:132
void SAL_CALL typelib_typedescriptionreference_new(typelib_TypeDescriptionReference **ppTDR, typelib_TypeClass eTypeClass, rtl_uString *pTypeName) SAL_THROW_EXTERN_C()
register sal_uInt32 r28 __asm__("%r28")
OUString runtimeToOUString(char const *runtimeString)
#define sal_False
#define INSERT_FLOAT(pSV, nr, pFPR, pDS)
#define INSERT_INT16(pSV, pDS)
void * p
#define INSERT_DOUBLE(pSV, nr, pFPR, pDS)
void dummy_can_throw_anything(char const *)
com::sun::star::uno::XInterface * getCppI()
sal_uInt16 nPos
char const * name