bridges/source/cpp_uno/gcc3_macosx_x86-64/cpp2uno.cxx

   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
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23
  24 #include <rtl/alloc.h>
  25 #include <sal/log.hxx>
  26
  27 #include <com/sun/star/uno/genfunc.hxx>
  28 #include <com/sun/star/uno/RuntimeException.hpp>
  29 #include <uno/data.h>
  30 #include <typelib/typedescription.hxx>
  31
  32 #include <bridge.hxx>
  33 #include <cppinterfaceproxy.hxx>
  34 #include <types.hxx>
  35 #include <vtablefactory.hxx>
  36
  37 #include "abi.hxx"
  38 #include "call.hxx"
  39 #include "share.hxx"
  40
  41 using namespace ::osl;
  42 using namespace ::com::sun::star::uno;
  43
  44
  45 // Perform the UNO call
  46 //
  47 // We must convert the parameters stored in gpreg, fpreg and ovrflw to UNO
  48 // arguments and call pThis->getUnoI()->pDispatcher.
  49 //
  50 // gpreg:  [ret *], this, [gpr params]
  51 // fpreg:  [fpr params]
  52 // ovrflw: [gpr or fpr params (properly aligned)]
  53 //
  54 // [ret *] is present when we are returning a structure bigger than 16 bytes
  55 // Simple types are returned in rax, rdx (int), or xmm0, xmm1 (fp).
  56 // Similarly structures <= 16 bytes are in rax, rdx, xmm0, xmm1 as necessary.
  57 static typelib_TypeClass cpp2uno_call(
  58     bridges::cpp_uno::shared::CppInterfaceProxy * pThis,
  59     const typelib_TypeDescription * pMemberTypeDescr,
  60     typelib_TypeDescriptionReference * pReturnTypeRef, // 0 indicates void return
  61     sal_Int32 nParams, typelib_MethodParameter * pParams,
  62     void ** gpreg, void ** fpreg, void ** ovrflw,
  63     sal_uInt64 * pRegisterReturn /* space for register return */ )
  64 {
  65     unsigned int nr_gpr = 0; //number of gpr registers used
  66     unsigned int nr_fpr = 0; //number of fpr registers used
  67
  68     // return
  69     typelib_TypeDescription * pReturnTypeDescr = nullptr;
  70     if (pReturnTypeRef)
  71         TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
  72
  73     void * pUnoReturn = nullptr;
  74     void * pCppReturn = nullptr; // complex return ptr: if != 0 && != pUnoReturn, reconversion need
  75
  76     if ( pReturnTypeDescr )
  77     {
  78         if ( x86_64::return_in_hidden_param( pReturnTypeRef ) )
  79         {
  80             pCppReturn = *gpreg++;
  81             nr_gpr++;
  82
  83             pUnoReturn = ( bridges::cpp_uno::shared::relatesToInterfaceType( pReturnTypeDescr )
  84                            ? alloca( pReturnTypeDescr->nSize )
  85                            : pCppReturn ); // direct way
  86         }
  87         else
  88             pUnoReturn = pRegisterReturn; // direct way for simple types
  89     }
  90
  91     // pop this
  92     gpreg++;
  93     nr_gpr++;
  94
  95     // stack space
  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 cpp<=>uno)
 100     sal_Int32 * pTempIndices = reinterpret_cast<sal_Int32 *>(pUnoArgs + (2 * nParams));
 101     // type descriptions for reconversions
 102     typelib_TypeDescription ** ppTempParamTypeDescr = reinterpret_cast<typelib_TypeDescription **>(pUnoArgs + (3 * nParams));
 103
 104     sal_Int32 nTempIndices = 0;
 105
 106     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
 107     {
 108         const typelib_MethodParameter & rParam = pParams[nPos];
 109
 110         int nUsedGPR = 0;
 111         int nUsedSSE = 0;
 112 #ifndef NDEBUG
 113         bool bFitsRegisters =
 114 #endif
 115             x86_64::examine_argument( rParam.pTypeRef, false, nUsedGPR, nUsedSSE );
 116         if ( !rParam.bOut && bridges::cpp_uno::shared::isSimpleType( rParam.pTypeRef ) ) // value
 117         {
 118             // Simple types must fit exactly one register on x86_64
 119             assert(bFitsRegisters && ( ( nUsedSSE == 1 && nUsedGPR == 0 ) || ( nUsedSSE == 0 && nUsedGPR == 1 ) ));
 120
 121             if ( nUsedSSE == 1 )
 122             {
 123                 if ( nr_fpr < x86_64::MAX_SSE_REGS )
 124                 {
 125                     pCppArgs[nPos] = pUnoArgs[nPos] = fpreg++;
 126                     nr_fpr++;
 127                 }
 128                 else
 129                     pCppArgs[nPos] = pUnoArgs[nPos] = ovrflw++;
 130             }
 131             else if ( nUsedGPR == 1 )
 132             {
 133                 if ( nr_gpr < x86_64::MAX_GPR_REGS )
 134                 {
 135                     pCppArgs[nPos] = pUnoArgs[nPos] = gpreg++;
 136                     nr_gpr++;
 137                 }
 138                 else
 139                     pCppArgs[nPos] = pUnoArgs[nPos] = ovrflw++;
 140             }
 141         }
 142         else // struct <= 16 bytes || ptr to complex value || ref
 143         {
 144             typelib_TypeDescription * pParamTypeDescr = nullptr;
 145             TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
 146
 147             void *pCppStack;
 148             if ( nr_gpr < x86_64::MAX_GPR_REGS )
 149             {
 150                 pCppArgs[nPos] = pCppStack = *gpreg++;
 151                 nr_gpr++;
 152             }
 153             else
 154                 pCppArgs[nPos] = pCppStack = *ovrflw++;
 155
 156             if (! rParam.bIn) // is pure out
 157             {
 158                 // uno out is unconstructed mem!
 159                 pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
 160                 pTempIndices[nTempIndices] = nPos;
 161                 // will be released at reconversion
 162                 ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
 163             }
 164             else if ( bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ) ) // is in/inout
 165             {
 166                 uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
 167                                         pCppStack, pParamTypeDescr,
 168                                         pThis->getBridge()->getCpp2Uno() );
 169                 pTempIndices[nTempIndices] = nPos; // has to be reconverted
 170                 // will be released at reconversion
 171                 ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
 172             }
 173             else // direct way
 174             {
 175                 pUnoArgs[nPos] = pCppStack;
 176                 // no longer needed
 177                 TYPELIB_DANGER_RELEASE( pParamTypeDescr );
 178             }
 179         }
 180     }
 181
 182     // ExceptionHolder
 183     uno_Any aUnoExc; // Any will be constructed by callee
 184     uno_Any * pUnoExc = &aUnoExc;
 185
 186     // invoke uno dispatch call
 187     (*pThis->getUnoI()->pDispatcher)( pThis->getUnoI(), pMemberTypeDescr, pUnoReturn, pUnoArgs, &pUnoExc );
 188
 189     // in case an exception occurred...
 190     if ( pUnoExc )
 191     {
 192         // destruct temporary in/inout params
 193         for ( ; nTempIndices--; )
 194         {
 195             sal_Int32 nIndex = pTempIndices[nTempIndices];
 196
 197             if (pParams[nIndex].bIn) // is in/inout => was constructed
 198                 uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], nullptr );
 199             TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
 200         }
 201         if (pReturnTypeDescr)
 202             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
 203
 204         CPPU_CURRENT_NAMESPACE::raiseException( &aUnoExc, pThis->getBridge()->getUno2Cpp() ); // has to destruct the any
 205         // is here for dummy
 206         return typelib_TypeClass_VOID;
 207     }
 208     else // else no exception occurred...
 209     {
 210         // temporary params
 211         for ( ; nTempIndices--; )
 212         {
 213             sal_Int32 nIndex = pTempIndices[nTempIndices];
 214             typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 215
 216             if ( pParams[nIndex].bOut ) // inout/out
 217             {
 218                 // convert and assign
 219                 uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
 220                 uno_copyAndConvertData( pCppArgs[nIndex], pUnoArgs[nIndex], pParamTypeDescr,
 221                                         pThis->getBridge()->getUno2Cpp() );
 222             }
 223             // destroy temp uno param
 224             uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, nullptr );
 225
 226             TYPELIB_DANGER_RELEASE( pParamTypeDescr );
 227         }
 228         // return
 229         if ( pCppReturn ) // has complex return
 230         {
 231             if ( pUnoReturn != pCppReturn ) // needs reconversion
 232             {
 233                 uno_copyAndConvertData( pCppReturn, pUnoReturn, pReturnTypeDescr,
 234                                         pThis->getBridge()->getUno2Cpp() );
 235                 // destroy temp uno return
 236                 uno_destructData( pUnoReturn, pReturnTypeDescr, nullptr );
 237             }
 238             // complex return ptr is set to return reg
 239             *reinterpret_cast<void **>(pRegisterReturn) = pCppReturn;
 240         }
 241         if ( pReturnTypeDescr )
 242         {
 243             typelib_TypeClass eRet = pReturnTypeDescr->eTypeClass;
 244             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
 245             return eRet;
 246         }
 247         else
 248             return typelib_TypeClass_VOID;
 249     }
 250 }
 251
 252 typelib_TypeClass cpp_vtable_call(
 253     sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset,
 254     void ** gpreg, void ** fpreg, void ** ovrflw,
 255     sal_uInt64 * pRegisterReturn /* space for register return */ )
 256 {
 257     // gpreg:  [ret *], this, [other gpr params]
 258     // fpreg:  [fpr params]
 259     // ovrflw: [gpr or fpr params (properly aligned)]
 260     void * pThis;
 261     if ( nFunctionIndex & 0x80000000 )
 262     {
 263         nFunctionIndex &= 0x7fffffff;
 264         pThis = gpreg[1];
 265     }
 266     else
 267     {
 268         pThis = gpreg[0];
 269     }
 270     pThis = static_cast<char *>( pThis ) - nVtableOffset;
 271
 272     bridges::cpp_uno::shared::CppInterfaceProxy * pCppI =
 273         bridges::cpp_uno::shared::CppInterfaceProxy::castInterfaceToProxy( pThis );
 274
 275     typelib_InterfaceTypeDescription * pTypeDescr = pCppI->getTypeDescr();
 276
 277     if ( nFunctionIndex >= pTypeDescr->nMapFunctionIndexToMemberIndex )
 278     {
 279         SAL_WARN(
 280             "bridges",
 281             "illegal " << OUString::unacquired(&pTypeDescr->aBase.pTypeName)
 282                 << " vtable index " << nFunctionIndex << "/"
 283                 << pTypeDescr->nMapFunctionIndexToMemberIndex);
 284         throw RuntimeException(
 285             ("illegal " + OUString::unacquired(&pTypeDescr->aBase.pTypeName)
 286              + " vtable index " + OUString::number(nFunctionIndex) + "/"
 287              + OUString::number(pTypeDescr->nMapFunctionIndexToMemberIndex)),
 288             reinterpret_cast<XInterface *>( pCppI ) );
 289     }
 290
 291     // determine called method
 292     sal_Int32 nMemberPos = pTypeDescr->pMapFunctionIndexToMemberIndex[nFunctionIndex];
 293     assert(nMemberPos < pTypeDescr->nAllMembers);
 294
 295     TypeDescription aMemberDescr( pTypeDescr->ppAllMembers[nMemberPos] );
 296
 297     typelib_TypeClass eRet;
 298     switch ( aMemberDescr.get()->eTypeClass )
 299     {
 300         case typelib_TypeClass_INTERFACE_ATTRIBUTE:
 301         {
 302             typelib_TypeDescriptionReference *pAttrTypeRef =
 303                 reinterpret_cast<typelib_InterfaceAttributeTypeDescription *>( aMemberDescr.get() )->pAttributeTypeRef;
 304
 305             if ( pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos] == nFunctionIndex )
 306             {
 307                 // is GET method
 308                 eRet = cpp2uno_call( pCppI, aMemberDescr.get(), pAttrTypeRef,
 309                         0, nullptr, // no params
 310                         gpreg, fpreg, ovrflw, pRegisterReturn );
 311             }
 312             else
 313             {
 314                 // is SET method
 315                 typelib_MethodParameter aParam;
 316                 aParam.pTypeRef = pAttrTypeRef;
 317                 aParam.bIn      = true;
 318                 aParam.bOut     = false;
 319
 320                 eRet = cpp2uno_call( pCppI, aMemberDescr.get(),
 321                         nullptr, // indicates void return
 322                         1, &aParam,
 323                         gpreg, fpreg, ovrflw, pRegisterReturn );
 324             }
 325             break;
 326         }
 327         case typelib_TypeClass_INTERFACE_METHOD:
 328         {
 329             // is METHOD
 330             switch ( nFunctionIndex )
 331             {
 332                 case 1: // acquire()
 333                     pCppI->acquireProxy(); // non virtual call!
 334                     eRet = typelib_TypeClass_VOID;
 335                     break;
 336                 case 2: // release()
 337                     pCppI->releaseProxy(); // non virtual call!
 338                     eRet = typelib_TypeClass_VOID;
 339                     break;
 340                 case 0: // queryInterface() opt
 341                 {
 342                     typelib_TypeDescription * pTD = nullptr;
 343                     TYPELIB_DANGER_GET( &pTD, static_cast<Type *>( gpreg[2] )->getTypeLibType() );
 344                     if ( pTD )
 345                     {
 346                         XInterface * pInterface = nullptr;
 347                         (*pCppI->getBridge()->getCppEnv()->getRegisteredInterface)
 348                             ( pCppI->getBridge()->getCppEnv(),
 349                               reinterpret_cast<void **>(&pInterface),
 350                               pCppI->getOid().pData,
 351                               reinterpret_cast<typelib_InterfaceTypeDescription *>( pTD ) );
 352
 353                         if ( pInterface )
 354                         {
 355                             ::uno_any_construct( static_cast<uno_Any *>( gpreg[0] ),
 356                                                  &pInterface, pTD, cpp_acquire );
 357
 358                             pInterface->release();
 359                             TYPELIB_DANGER_RELEASE( pTD );
 360
 361                             reinterpret_cast<void **>( pRegisterReturn )[0] = gpreg[0];
 362                             eRet = typelib_TypeClass_ANY;
 363                             break;
 364                         }
 365                         TYPELIB_DANGER_RELEASE( pTD );
 366                     }
 367                     [[fallthrough]]; // else perform queryInterface()
 368                 }
 369                 default:
 370                 {
 371                     typelib_InterfaceMethodTypeDescription *pMethodTD =
 372                         reinterpret_cast<typelib_InterfaceMethodTypeDescription *>( aMemberDescr.get() );
 373
 374                     eRet = cpp2uno_call( pCppI, aMemberDescr.get(),
 375                                          pMethodTD->pReturnTypeRef,
 376                                          pMethodTD->nParams,
 377                                          pMethodTD->pParams,
 378                                          gpreg, fpreg, ovrflw, pRegisterReturn );
 379                 }
 380             }
 381             break;
 382         }
 383         default:
 384         {
 385             throw RuntimeException("no member description found!",
 386                                     reinterpret_cast<XInterface *>( pCppI ) );
 387         }
 388     }
 389
 390     return eRet;
 391 }
 392
 393 const int codeSnippetSize = 24;
 394
 395 // Generate a trampoline that redirects method calls to
 396 // privateSnippetExecutor().
 397 //
 398 // privateSnippetExecutor() saves all the registers that are used for
 399 // parameter passing on x86_64, and calls the cpp_vtable_call().
 400 // When it returns, privateSnippetExecutor() sets the return value.
 401 //
 402 // Note: The code snippet we build here must not create a stack frame,
 403 // otherwise the UNO exceptions stop working thanks to non-existing
 404 // unwinding info.
 405 static unsigned char * codeSnippet( unsigned char * code,
 406         sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset,
 407         bool bHasHiddenParam )
 408 {
 409     sal_uInt64 nOffsetAndIndex = ( static_cast<sal_uInt64>(nVtableOffset) << 32 ) | static_cast<sal_uInt64>(nFunctionIndex);
 410
 411     if ( bHasHiddenParam )
 412         nOffsetAndIndex |= 0x80000000;
 413
 414     // movq $<nOffsetAndIndex>, %r10
 415     *reinterpret_cast<sal_uInt16 *>( code ) = 0xba49;
 416     *reinterpret_cast<sal_uInt16 *>( code + 2 ) = nOffsetAndIndex & 0xFFFF;
 417     *reinterpret_cast<sal_uInt32 *>( code + 4 ) = nOffsetAndIndex >> 16;
 418     *reinterpret_cast<sal_uInt16 *>( code + 8 ) = nOffsetAndIndex >> 48;
 419
 420     // movq $<address of the privateSnippetExecutor>, %r11
 421     *reinterpret_cast<sal_uInt16 *>( code + 10 ) = 0xbb49;
 422     *reinterpret_cast<sal_uInt32 *>( code + 12 )
 423         = reinterpret_cast<sal_uInt64>(privateSnippetExecutor);
 424     *reinterpret_cast<sal_uInt32 *>( code + 16 )
 425         = reinterpret_cast<sal_uInt64>(privateSnippetExecutor) >> 32;
 426
 427     // jmpq *%r11
 428     *reinterpret_cast<sal_uInt32 *>( code + 20 ) = 0x00e3ff49;
 429
 430 #if OSL_DEBUG_LEVEL > 1
 431     fprintf(stderr,
 432             "==> codeSnippet, functionIndex=%d%s, vtableOffset=%d\n",
 433             nFunctionIndex, (bHasHiddenParam ? "|0x80000000":""), nVtableOffset);
 434 #endif
 435
 436     return code + codeSnippetSize;
 437 }
 438
 439 struct bridges::cpp_uno::shared::VtableFactory::Slot { void * fn; };
 440
 441 bridges::cpp_uno::shared::VtableFactory::Slot *
 442 bridges::cpp_uno::shared::VtableFactory::mapBlockToVtable(void * block)
 443 {
 444     return static_cast< Slot * >(block) + 2;
 445 }
 446
 447 std::size_t bridges::cpp_uno::shared::VtableFactory::getBlockSize(
 448     sal_Int32 slotCount)
 449 {
 450     return (slotCount + 2) * sizeof (Slot) + slotCount * codeSnippetSize;
 451 }
 452
 453 bridges::cpp_uno::shared::VtableFactory::Slot *
 454 bridges::cpp_uno::shared::VtableFactory::initializeBlock(
 455     void * block, sal_Int32 slotCount, sal_Int32,
 456     typelib_InterfaceTypeDescription *)
 457 {
 458     Slot * slots = mapBlockToVtable(block);
 459     slots[-2].fn = nullptr;
 460     slots[-1].fn = nullptr;
 461     return slots + slotCount;
 462 }
 463
 464
 465 unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
 466     Slot ** slots, unsigned char * code,
 467     typelib_InterfaceTypeDescription const * type, sal_Int32 nFunctionOffset,
 468     sal_Int32 functionCount, sal_Int32 nVtableOffset )
 469 {
 470     const sal_PtrDiff writetoexecdiff = 0;
 471     (*slots) -= functionCount;
 472     Slot * s = *slots;
 473     for ( sal_Int32 nPos = 0; nPos < type->nMembers; ++nPos )
 474     {
 475         typelib_TypeDescription * pTD = nullptr;
 476
 477         TYPELIB_DANGER_GET( &pTD, type->ppMembers[ nPos ] );
 478         assert(pTD);
 479
 480         if ( typelib_TypeClass_INTERFACE_ATTRIBUTE == pTD->eTypeClass )
 481         {
 482             typelib_InterfaceAttributeTypeDescription *pAttrTD =
 483                 reinterpret_cast<typelib_InterfaceAttributeTypeDescription *>( pTD );
 484
 485             // get method
 486             (s++)->fn = code + writetoexecdiff;
 487             code = codeSnippet( code, nFunctionOffset++, nVtableOffset,
 488                                 x86_64::return_in_hidden_param( pAttrTD->pAttributeTypeRef ) );
 489
 490             if ( ! pAttrTD->bReadOnly )
 491             {
 492                 // set method
 493                 (s++)->fn = code + writetoexecdiff;
 494                 code = codeSnippet( code, nFunctionOffset++, nVtableOffset, false );
 495             }
 496         }
 497         else if ( typelib_TypeClass_INTERFACE_METHOD == pTD->eTypeClass )
 498         {
 499             typelib_InterfaceMethodTypeDescription *pMethodTD =
 500                 reinterpret_cast<typelib_InterfaceMethodTypeDescription *>( pTD );
 501
 502             (s++)->fn = code + writetoexecdiff;
 503             code = codeSnippet( code, nFunctionOffset++, nVtableOffset,
 504                                 x86_64::return_in_hidden_param( pMethodTD->pReturnTypeRef ) );
 505         }
 506         else
 507             assert(false);
 508
 509         TYPELIB_DANGER_RELEASE( pTD );
 510     }
 511     return code;
 512 }
 513
 514 void bridges::cpp_uno::shared::VtableFactory::flushCode(
 515     SAL_UNUSED_PARAMETER unsigned char const *,
 516     SAL_UNUSED_PARAMETER unsigned char const * )
 517 {}
 518
 519 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */