Compiling but not working mingw_x86-64 bridges

Change-Id: I5ea6edf367dd18e60a86d12c523b7732a8ac44d4

bridges/Library_cpp_uno.mk

@@ -135,10 +135,9 @@ bridge_noopt_objects := except
 bridge_asm_objects := call
 else ifeq ($(OS)$(COM),WNTGCC)
 bridges_SELECTED_BRIDGE := mingw_x86-64
-#bridge_asm_objects := call
-bridge_noopt_objects := uno2cpp
-bridge_exception_objects := callvirtualmethod cpp2uno dllinit except smallstruct
-#bridge_exception_objects := cpp2uno dllinit except smallstruct
+bridge_asm_objects := call
+bridge_noncallexception_noopt_objects := callvirtualmethod
+bridge_exception_objects := abi cpp2uno except uno2cpp
 endif
 
 else ifeq ($(OS)$(CPU),SOLARISI)

bridges/source/cpp_uno/mingw_x86-64/dllinit.cxx → bridges/source/cpp_uno/mingw_x86-64/abi.hxx

@@ -17,29 +17,45 @@
  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  */
 
-#include <windows.h>
+#ifndef _BRIDGES_CPP_UNO_X86_64_ABI_HXX_
+#define _BRIDGES_CPP_UNO_X86_64_ABI_HXX_
 
+// This is an implementation of the x86-64 ABI as described in 'System V
+// Application Binary Interface, AMD64 Architecture Processor Supplement'
+// (http://www.x86-64.org/documentation/abi-0.95.pdf)
 
-void dso_init(void);
-void dso_exit(void);
+#include <typelib/typedescription.hxx>
 
-
-extern "C" BOOL WINAPI DllMain(HMODULE hModule, DWORD dwReason, LPVOID lpvReserved)
+namespace x86_64
 {
-    switch(dwReason) {
-    case DLL_PROCESS_ATTACH:
-        DisableThreadLibraryCalls(hModule);
 
-        dso_init();
-        break;
+/* 6 general purpose registers are used for parameter passing */
+const sal_uInt32 MAX_GPR_REGS = 6;
+
+/* 8 SSE registers are used for parameter passing */
+const sal_uInt32 MAX_SSE_REGS = 8;
+
+/* Count number of required registers.
+
+ Examine the argument and return set number of register required in each
+ class.
+
+ Return false iff parameter should be passed in memory.
+*/
+bool examine_argument( typelib_TypeDescriptionReference *pTypeRef, bool bInReturn, int &nUsedGPR, int &nUsedSSE ) throw ();
+
+/** Does function that returns this type use a hidden parameter, or registers?
+
+ The value can be returned either in a hidden 1st parameter (which is a
+ pointer to a structure allocated by the caller), or in registers (rax, rdx
+ for the integers, xmm0, xmm1 for the floating point numbers).
+*/
+bool return_in_hidden_param( typelib_TypeDescriptionReference *pTypeRef ) throw ();
+
+void fill_struct( typelib_TypeDescriptionReference *pTypeRef, const sal_uInt64* pGPR, const double* pSSE, void *pStruct ) throw ();
 
-    case DLL_PROCESS_DETACH:
-        if (!lpvReserved)
-            dso_exit();
-        break;
-    }
+} // namespace x86_64
 
-    return TRUE;
-}
+#endif // _BRIDGES_CPP_UNO_X86_64_ABI_HXX_
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

bridges/source/cpp_uno/mingw_x86-64/callvirtualmethod.cxx

@@ -19,120 +19,147 @@
 
 #include "sal/config.h"
 
+#include <cstring>
+
 #include "cppu/macros.hxx"
-#include "osl/diagnose.h"
 #include "sal/types.h"
 #include "typelib/typeclass.h"
 #include "typelib/typedescription.h"
 
+#include "abi.hxx"
 #include "callvirtualmethod.hxx"
-#include "share.hxx"
-#include "smallstruct.hxx"
-
-// For some reason, callVirtualMethod needs to be in a source file of its own,
-// so that stack unwinding upon a thrown exception from within the asm block
-// call works, at least with GCC 4.7.0 and --enable-dbgutil.
-
-// The call instruction within the asm section of callVirtualMethod may throw
-// exceptions.  So that the compiler handles this correctly, it is important
-// that (a) callVirtualMethod might call dummy_can_throw_anything (although this
-// never happens at runtime), which in turn can throw exceptions, and (b)
-// callVirtualMethod is not inlined at its call site (so that any exceptions are
-// caught which are thrown from the instruction calling callVirtualMethod).  [It
-// is unclear how much of this comment is still relevent -- see the above
-// comment.]
+
+// The call instruction within the asm block of callVirtualMethod may throw
+// exceptions.  At least GCC 4.7.0 with -O0 would create (unnecessary)
+// .gcc_exception_table call-site table entries around all other calls in this
+// function that can throw, leading to std::terminate if the asm call throws an
+// exception and the unwinding C++ personality routine finds the unexpected hole
+// in the .gcc_exception_table.  Therefore, make sure this function explicitly
+// only calls nothrow-functions (so GCC 4.7.0 with -O0 happens to not create a
+// .gcc_exception_table section at all for this function).  For some reason,
+// this also needs to be in a source file of its own.
+//
+// Also, this file should be compiled with -fnon-call-exceptions, and ideally
+// there would be a way to tell the compiler that the asm block contains calls
+// to functions that can potentially throw; see the mail thread starting at
+// <http://gcc.gnu.org/ml/gcc/2012-03/msg00454.html> "C++: Letting compiler know
+// asm block can call function that can throw?"
+
 void CPPU_CURRENT_NAMESPACE::callVirtualMethod(
-    void * pAdjustedThisPtr, sal_Int32 nVtableIndex, void * pRegisterReturn,
-    typelib_TypeDescription const * returnType, sal_Int32 * pStackLongs,
-    sal_Int32 nStackLongs)
+    void * pThis, sal_uInt32 nVtableIndex, void * pRegisterReturn,
+    typelib_TypeDescriptionReference * pReturnTypeRef, bool bSimpleReturn,
+    sal_uInt64 *pStack, sal_uInt32 nStack, sal_uInt64 *pGPR, sal_uInt32 nGPR,
+    double * pFPR, sal_uInt32 nFPR)
 {
-    // parameter list is mixed list of * and values
-    // reference parameters are pointers
+    // Should not happen, but...
+    if ( nFPR > x86_64::MAX_SSE_REGS )
+        nFPR = x86_64::MAX_SSE_REGS;
+    if ( nGPR > x86_64::MAX_GPR_REGS )
+        nGPR = x86_64::MAX_GPR_REGS;
 
-    OSL_ENSURE( pStackLongs && pAdjustedThisPtr, "### null ptr!" );
-    OSL_ENSURE( (sizeof(void *) == 4) && (sizeof(sal_Int32) == 4), "### unexpected size of int!" );
-    OSL_ENSURE( nStackLongs && pStackLongs, "### no stack in callVirtualMethod !" );
+    // Get pointer to method
+    sal_uInt64 pMethod = *((sal_uInt64 *)pThis);
+    pMethod += 8 * nVtableIndex;
+    pMethod = *((sal_uInt64 *)pMethod);
 
-    // never called
-    if (! pAdjustedThisPtr) CPPU_CURRENT_NAMESPACE::dummy_can_throw_anything("xxx"); // address something
+    // Load parameters to stack, if necessary
+    sal_uInt64* pCallStack = NULL;
+    if ( nStack )
+    {
+        // 16-bytes aligned
+        sal_uInt32 nStackBytes = ( ( nStack + 1 ) >> 1 ) * 16;
+        pCallStack = (sal_uInt64 *) __builtin_alloca( nStackBytes );
+        std::memcpy( pCallStack, pStack, nStackBytes );
+    }
+
+    // Return values
+    sal_uInt64 rax;
+    sal_uInt64 rdx;
+    double xmm0;
+    double xmm1;
 
-    volatile long edx = 0, eax = 0; // for register returns
-    void * stackptr;
     asm volatile (
-        "mov   %%esp, %6\n\t"
-        // copy values
-        "mov   %0, %%eax\n\t"
-        "mov   %%eax, %%edx\n\t"
-        "dec   %%edx\n\t"
-        "shl   $2, %%edx\n\t"
-        "add   %1, %%edx\n"
-        "Lcopy:\n\t"
-        "pushl 0(%%edx)\n\t"
-        "sub   $4, %%edx\n\t"
-        "dec   %%eax\n\t"
-        "jne   Lcopy\n\t"
-        // do the actual call
-        "mov   %2, %%edx\n\t"
-        "mov   0(%%edx), %%edx\n\t"
-        "mov   %3, %%eax\n\t"
-        "shl   $2, %%eax\n\t"
-        "add   %%eax, %%edx\n\t"
-        "mov   0(%%edx), %%edx\n\t"
-        "call  *%%edx\n\t"
-        // save return registers
-         "mov   %%eax, %4\n\t"
-         "mov   %%edx, %5\n\t"
-        // cleanup stack
-        "mov   %6, %%esp\n\t"
-        :
-        : "m"(nStackLongs), "m"(pStackLongs), "m"(pAdjustedThisPtr),
-          "m"(nVtableIndex), "m"(eax), "m"(edx), "m"(stackptr)
-        : "eax", "ecx", "edx" );
-    switch( returnType->eTypeClass )
+
+        // Fill the xmm registers
+        "movq %6, %%rax\n\t"
+
+        "movsd   (%%rax), %%xmm0\n\t"
+        "movsd  8(%%rax), %%xmm1\n\t"
+        "movsd 16(%%rax), %%xmm2\n\t"
+        "movsd 24(%%rax), %%xmm3\n\t"
+        "movsd 32(%%rax), %%xmm4\n\t"
+        "movsd 40(%%rax), %%xmm5\n\t"
+        "movsd 48(%%rax), %%xmm6\n\t"
+        "movsd 56(%%rax), %%xmm7\n\t"
+
+        // Fill the general purpose registers
+        "movq %5, %%rax\n\t"
+
+        "movq    (%%rax), %%rdi\n\t"
+        "movq   8(%%rax), %%rsi\n\t"
+        "movq  16(%%rax), %%rdx\n\t"
+        "movq  24(%%rax), %%rcx\n\t"
+        "movq  32(%%rax), %%r8\n\t"
+        "movq  40(%%rax), %%r9\n\t"
+
+        // Perform the call
+        "movq %4, %%r11\n\t"
+        "movq %7, %%rax\n\t"
+        "call *%%r11\n\t"
+
+        // Fill the return values
+        "movq   %%rax, %0\n\t"
+        "movq   %%rdx, %1\n\t"
+        "movsd %%xmm0, %2\n\t"
+        "movsd %%xmm1, %3\n\t"
+        : "=m" ( rax ), "=m" ( rdx ), "=m" ( xmm0 ), "=m" ( xmm1 )
+        : "m" ( pMethod ), "m" ( pGPR ), "m" ( pFPR ), "m" ( nFPR ),
+          "m" ( pCallStack ) // dummy input to prevent the compiler from optimizing the alloca out
+        : "rax", "rdi", "rsi", "rdx", "rcx", "r8", "r9", "r10", "r11",
+          "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
+          "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
+    );
+
+    switch (pReturnTypeRef->eTypeClass)
     {
-        case typelib_TypeClass_VOID:
-            break;
-        case typelib_TypeClass_HYPER:
-        case typelib_TypeClass_UNSIGNED_HYPER:
-            ((long*)pRegisterReturn)[1] = edx;
-        case typelib_TypeClass_LONG:
-        case typelib_TypeClass_UNSIGNED_LONG:
-        case typelib_TypeClass_CHAR:
-        case typelib_TypeClass_ENUM:
-            ((long*)pRegisterReturn)[0] = eax;
-            break;
-        case typelib_TypeClass_SHORT:
-        case typelib_TypeClass_UNSIGNED_SHORT:
-            *(unsigned short*)pRegisterReturn = eax;
-            break;
-        case typelib_TypeClass_BOOLEAN:
-        case typelib_TypeClass_BYTE:
-            *(unsigned char*)pRegisterReturn = eax;
-            break;
-        case typelib_TypeClass_FLOAT:
-            asm ( "fstps %0" : : "m"(*(char *)pRegisterReturn) );
-            break;
-        case typelib_TypeClass_DOUBLE:
-            asm ( "fstpl %0\n\t" : : "m"(*(char *)pRegisterReturn) );
-            break;
-        case typelib_TypeClass_STRUCT:
-            if (bridges::cpp_uno::shared::isSmallStruct(returnType)) {
-                        if (returnType->nSize <= 1) {
-                    *(unsigned char*)pRegisterReturn = eax;
-                    }
-                    else if (returnType->nSize <= 2) {
-                    *(unsigned short*)pRegisterReturn = eax;
-                    }
-                        else if (returnType->nSize <= 8) {
-                    ((long*)pRegisterReturn)[0] = eax;
-                        if (returnType->nSize > 4) {
-                        ((long*)pRegisterReturn)[1] = edx;
-                    }
-                           }
-                }
-            break;
-        default:
+    case typelib_TypeClass_HYPER:
+    case typelib_TypeClass_UNSIGNED_HYPER:
+        *reinterpret_cast<sal_uInt64 *>( pRegisterReturn ) = rax;
         break;
+    case typelib_TypeClass_LONG:
+    case typelib_TypeClass_UNSIGNED_LONG:
+    case typelib_TypeClass_ENUM:
+        *reinterpret_cast<sal_uInt32 *>( pRegisterReturn ) = *reinterpret_cast<sal_uInt32*>( &rax );
+        break;
+    case typelib_TypeClass_CHAR:
+    case typelib_TypeClass_SHORT:
+    case typelib_TypeClass_UNSIGNED_SHORT:
+        *reinterpret_cast<sal_uInt16 *>( pRegisterReturn ) = *reinterpret_cast<sal_uInt16*>( &rax );
+        break;
+    case typelib_TypeClass_BOOLEAN:
+    case typelib_TypeClass_BYTE:
+        *reinterpret_cast<sal_uInt8 *>( pRegisterReturn ) = *reinterpret_cast<sal_uInt8*>( &rax );
+        break;
+    case typelib_TypeClass_FLOAT:
+    case typelib_TypeClass_DOUBLE:
+        *reinterpret_cast<double *>( pRegisterReturn ) = xmm0;
+        break;
+    default:
+        {
+            sal_Int32 const nRetSize = pReturnTypeRef->pType->nSize;
+            if (bSimpleReturn && nRetSize <= 16 && nRetSize > 0)
+            {
+                sal_uInt64 longs[2];
+                longs[0] = rax;
+                longs[1] = rdx;
+
+                double doubles[2];
+                doubles[0] = xmm0;
+                doubles[1] = xmm1;
+                x86_64::fill_struct( pReturnTypeRef, &longs[0], &doubles[0], pRegisterReturn);
+            }
+            break;
+        }
     }
 }
 

bridges/source/cpp_uno/mingw_x86-64/callvirtualmethod.hxx

@@ -17,8 +17,8 @@
  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  */
 
-#ifndef INCLUDED_BRIDGES_SOURCE_CPP_UNO_MINGW_INTEL_CALLVIRTUALMETHOD_HXX
-#define INCLUDED_BRIDGES_SOURCE_CPP_UNO_MINGW_INTEL_CALLVIRTUALMETHOD_HXX
+#ifndef INCLUDED_BRIDGES_SOURCE_CPP_UNO_GCC3_LINUX_X86_64_CALLVIRTUALMETHOD_HXX
+#define INCLUDED_BRIDGES_SOURCE_CPP_UNO_GCC3_LINUX_X86_64_CALLVIRTUALMETHOD_HXX
 
 #include "sal/config.h"
 
@@ -29,9 +29,10 @@
 namespace CPPU_CURRENT_NAMESPACE {
 
 void callVirtualMethod(
-    void * pAdjustedThisPtr, sal_Int32 nVtableIndex, void * pRegisterReturn,
-    typelib_TypeDescription const * returnType, sal_Int32 * pStackLongs,
-    sal_Int32 nStackLongs);
+    void * pThis, sal_uInt32 nVtableIndex, void * pRegisterReturn,
+    typelib_TypeDescriptionReference * pReturnTypeRef, bool bSimpleReturn,
+    sal_uInt64 *pStack, sal_uInt32 nStack, sal_uInt64 *pGPR, sal_uInt32 nGPR,
+    double * pFPR, sal_uInt32 nFPR);
 
 }
 

bridges/source/cpp_uno/mingw_x86-64/smallstruct.cxx

-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * This file is part of the LibreOffice project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * This file incorporates work covered by the following license notice:
- *
- *   Licensed to the Apache Software Foundation (ASF) under one or more
- *   contributor license agreements. See the NOTICE file distributed
- *   with this work for additional information regarding copyright
- *   ownership. The ASF licenses this file to you under the Apache
- *   License, Version 2.0 (the "License"); you may not use this file
- *   except in compliance with the License. You may obtain a copy of
- *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
- */
-
-
-#include "bridges/cpp_uno/shared/types.hxx"
-
-#include "typelib/typeclass.h"
-#include "typelib/typedescription.h"
-
-namespace bridges { namespace cpp_uno { namespace shared {
-
-namespace {
-bool isSimpleStruct(typelib_TypeDescription const * type) {
-    switch (type->eTypeClass) {
-    case typelib_TypeClass_STRUCT:
-        {
-            typelib_CompoundTypeDescription const * p
-                = reinterpret_cast< typelib_CompoundTypeDescription const * >(
-                    type);
-            for (sal_Int32 i = 0; i < p->nMembers; ++i) {
-                switch (p->ppTypeRefs[i]->eTypeClass) {
-                case typelib_TypeClass_STRUCT:
-                    {
-                        typelib_TypeDescription * t = 0;
-                        TYPELIB_DANGER_GET(&t, p->ppTypeRefs[i]);
-                        bool b = isSimpleStruct(t);
-                        TYPELIB_DANGER_RELEASE(t);
-                        if (!b) {
-                            return false;
-                        }
-                    }
-                    break;
-
-                default:
-                    if (!isSimpleType(p->ppTypeRefs[i]->eTypeClass))
-            return false;
-            break;
-                }
-            }
-        }
-        return true;
-
-    default:
-        return false;
-    }
-}
-}
-
-bool isSmallStruct(typelib_TypeDescription const * type) {
-    return (type->nSize <= 8 && isSimpleStruct(type));
-}
-
-} } }
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

bridges/source/cpp_uno/mingw_x86-64/smallstruct.hxx

-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * This file is part of the LibreOffice project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * This file incorporates work covered by the following license notice:
- *
- *   Licensed to the Apache Software Foundation (ASF) under one or more
- *   contributor license agreements. See the NOTICE file distributed
- *   with this work for additional information regarding copyright
- *   ownership. The ASF licenses this file to you under the Apache
- *   License, Version 2.0 (the "License"); you may not use this file
- *   except in compliance with the License. You may obtain a copy of
- *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
- */
-
-#include "typelib/typeclass.h"
-#include "typelib/typedescription.h"
-
-namespace bridges { namespace cpp_uno { namespace shared {
-
-bool isSmallStruct(typelib_TypeDescription const * type);
-
-} } }
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */