(riscv64) Fix Java bridgetest failure

* Refactor the code related to struct processing. Fix Java bridge-
  test failure. Fixed test list:
  * bridgetest-javaserver
  * [CUT] smoketest
  * [JUT] forms_unoapi_1
  * [JUT] forms_unoapi_2
  * [JUT] forms_unoapi_3
  * [JUT] forms_unoapi_4
* Clean higher bit to prevent compiler generate wrong code when
  pyuno calls functions through UNO environment. This fixes some
  weired uitest failure.
* Reorder the datatype list. Optimize the inserting args section in
  uno2cpp.cxx.
* Remove some unused code.

Change-Id: I74330126d31d847485b1d81fc34376b1d020f886
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/160970
Tested-by: Jenkins
Tested-by: René Engelhard <rene@debian.org>
Reviewed-by: Stephan Bergmann <stephan.bergmann@allotropia.de>

4 files changed, 370 insertions, 200 deletions

diff --git a/bridges/source/cpp_uno/gcc3_linux_riscv64/abi.cxx b/bridges/source/cpp_uno/gcc3_linux_riscv64/abi.cxx
index b090953efde9..29b1975a316e 100644
--- a/bridges/source/cpp_uno/gcc3_linux_riscv64/abi.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_riscv64/abi.cxx
@@ -19,7 +19,22 @@
 

 namespace abi_riscv64

 {

-void countnGreg(sal_Int32& nGreg, sal_Int32& nFreg,

+/*

+   F: floating point reg

+   G: general purpose reg

+*/

+enum class ReturnKind

+{

+    FF_Align4,

+    FF_Align8,

+    FG_Align4,

+    FG_Align8,

+    GF_Align4,

+    GF_Align8,

+    DEFAULT

+};

+

+void countnGreg(sal_Int32& nGreg, sal_Int32& nFreg, bool& firstIsGreg, sal_Int32& align,

                 const typelib_CompoundTypeDescription* pTypeDescr)

 {

     for (int i = 0; i < pTypeDescr->nMembers; i++)

@@ -33,63 +48,257 @@ void countnGreg(sal_Int32& nGreg, sal_Int32& nFreg,
                 typelib_TypeDescription* childTypeDescr = nullptr;

                 TYPELIB_DANGER_GET(&childTypeDescr, pTypeInStruct);

                 countnGreg(

-                    nGreg, nFreg,

+                    nGreg, nFreg, firstIsGreg, align,

                     reinterpret_cast<typelib_CompoundTypeDescription const*>(childTypeDescr));

                 TYPELIB_DANGER_RELEASE(childTypeDescr);

             }

             break;

-            case typelib_TypeClass_FLOAT:

             case typelib_TypeClass_DOUBLE:

+                // Align to the larger type

+                align = 8;

+                [[fallthrough]];

+            case typelib_TypeClass_FLOAT:

                 nFreg++;

                 break;

+            case typelib_TypeClass_HYPER:

+            case typelib_TypeClass_UNSIGNED_HYPER:

+                align = 8;

+                [[fallthrough]];

             default:

+                if (nFreg > 0)

+                {

+                    firstIsGreg = false;

+                }

                 nGreg++;

                 break;

         }

     }

 }

 

-void fillStruct(const typelib_TypeDescription* pTypeDescr, sal_Int64* gret, double* fret,

-                void* pRegisterReturn)

+ReturnKind getReturnKind(const typelib_TypeDescription* pTypeDescr)

 {

-#ifdef BRIDGE_DEBUG

-    printf("In fillStruct, pTypeDescr = %p, gret = %p, fret = %p, pRegisterReturn = %p\n",

-           pTypeDescr, gret, fret, pRegisterReturn);

-#endif

     sal_Int32 nGreg = 0;

     sal_Int32 nFreg = 0;

-    countnGreg(nGreg, nFreg, reinterpret_cast<typelib_CompoundTypeDescription const*>(pTypeDescr));

-    char* pAdjust = reinterpret_cast<char*>(pRegisterReturn);

-    if (nGreg == 0 && nFreg <= 2)

+    sal_Int32 align = 4;

+    bool firstIsGreg = true;

+    countnGreg(nGreg, nFreg, firstIsGreg, align,

+               reinterpret_cast<typelib_CompoundTypeDescription const*>(pTypeDescr));

+    if (nGreg == 0 && nFreg == 2)

     {

-        if (pTypeDescr->nSize <= 8 && nFreg == 2)

-        {

-            std::memcpy(pAdjust, fret, 4);

-            std::memcpy(pAdjust + 4, fret + 1, 4);

-        }

+        if (align == 4)

+            return ReturnKind::FF_Align4;

         else

-        {

-            std::memcpy(pAdjust, fret, 16);

-        }

+            return ReturnKind::FF_Align8;

     }

-    else if (nFreg == 1 && nGreg == 1)

+    else if (nGreg == 1 && nFreg == 1)

     {

-        if (pTypeDescr->nSize > 8)

+        if (firstIsGreg)

         {

-            std::memcpy(pAdjust, gret, 8);

-            std::memcpy(pAdjust + 8, fret, 8);

+            if (align == 4)

+                return ReturnKind::GF_Align4;

+            else

+                return ReturnKind::GF_Align8;

         }

         else

         {

-            std::memcpy(pAdjust, gret, 4);

-            std::memcpy(pAdjust + 4, fret, 4);

+            if (align == 4)

+                return ReturnKind::FG_Align4;

+            else

+                return ReturnKind::FG_Align8;

         }

     }

     else

     {

-        std::memcpy(pAdjust, gret, 16);

+        return ReturnKind::DEFAULT;

+    }

+}

+

+/*

+    Transform the returned cpp data to uno.

+    This happens at the end of uno2cpp, when callee cpp func finished.

+

+                  |    returned data saved in

+    default cases |     gret[0] and gret[1]

+    2 float       |     fret[0] and fret[1]

+    1 float 1 int |     gret[0] and fret[0]

+

+    There is a complex problem -- alignment. For example, 4 byte float and 8 byte

+    integer take 16 bytes rather than 12 bytes.

+

+    There is also another complex problem. e.g. Two 4 byte integer is compacted

+    in a0, but two 4 byte float is seperately set in fa0 and fa1. However, return

+    size is 8 bytes. We need to cut the lower 32bit of fa0 and fa1 seperately and

+    combine them in 8 bytes.

+*/

+void fillUNOStruct(const typelib_TypeDescription* pTypeDescr, sal_Int64* gret, double* fret,

+                   void* pRegisterReturn)

+{

+#ifdef BRIDGE_DEBUG

+    printf("In fillStruct, pTypeDescr = %p, gret = %p, fret = %p, pRegisterReturn = %p\n",

+           pTypeDescr, gret, fret, pRegisterReturn);

+#endif

+    ReturnKind returnKind = getReturnKind(pTypeDescr);

+    switch (returnKind)

+    {

+        case ReturnKind::FF_Align4:

+            memcpy(reinterpret_cast<char*>(pRegisterReturn), &(fret[0]), 4);

+            memcpy(reinterpret_cast<char*>(pRegisterReturn) + 4, &(fret[1]), 4);

+            break;

+        case ReturnKind::FF_Align8:

+            reinterpret_cast<double*>(pRegisterReturn)[0] = fret[0];

+            reinterpret_cast<double*>(pRegisterReturn)[1] = fret[1];

+            break;

+        case ReturnKind::FG_Align4:

+            memcpy(reinterpret_cast<char*>(pRegisterReturn), &(fret[0]), 4);

+            memcpy(reinterpret_cast<char*>(pRegisterReturn) + 4, &(gret[0]), 4);

+            break;

+        case ReturnKind::FG_Align8:

+            reinterpret_cast<double*>(pRegisterReturn)[0] = fret[0];

+            reinterpret_cast<sal_Int64*>(pRegisterReturn)[1] = gret[0];

+            break;

+        case ReturnKind::GF_Align4:

+            memcpy(reinterpret_cast<char*>(pRegisterReturn), &(gret[0]), 4);

+            memcpy(reinterpret_cast<char*>(pRegisterReturn) + 4, &(fret[0]), 4);

+            break;

+        case ReturnKind::GF_Align8:

+            reinterpret_cast<sal_Int64*>(pRegisterReturn)[0] = gret[0];

+            reinterpret_cast<double*>(pRegisterReturn)[1] = fret[0];

+            break;

+        default:

+            reinterpret_cast<sal_Int64*>(pRegisterReturn)[0] = gret[0];

+            reinterpret_cast<sal_Int64*>(pRegisterReturn)[1] = gret[1];

+            break;

     }

 }

+

+/*

+    Split zipped unoreturn to cpp func. This happens at the end of cpp2uno.

+

+    The data in pTarget will be extrat to return regs in privateSnippetExecutor:

+                  |  pTarget[0]  |  pTarget[1]  | return type |

+    default cases |     $a0      |     $a1      |      0      |

+    2 float       |     $fa0     |     $fa1     |      0      |

+    1 float 1 int |     $a0      |     $fa0     |      1      |

+

+    This looks like a reverse version of fillUNOStruct. The reason for such

+    "meaningless" effort is that java return a compact struct, but cpp not.

+*/

+void splitUNOStruct(const typelib_TypeDescription* pTypeDescr, sal_uInt64* pTarget,

+                    sal_uInt64* pSource, sal_Int32& returnType)

+{

+#ifdef BRIDGE_DEBUG

+    printf("In splitUNOStruct, pTypeDescr = %p, pTarget = %p, pSource = %p\n", pTypeDescr, pTarget,

+           pSource);

+#endif

+    sal_uInt64* pTemp = (sal_uInt64*)calloc(2, sizeof(sal_uInt64));

+    ReturnKind returnKind = getReturnKind(pTypeDescr);

+    switch (returnKind)

+    {

+        case ReturnKind::FF_Align4:

+            memcpy(reinterpret_cast<char*>(pTemp), reinterpret_cast<char*>(pSource), 4);

+            memset(reinterpret_cast<char*>(pTemp) + 4, 0xFF, 4);

+            memcpy(reinterpret_cast<char*>(pTemp) + 8, reinterpret_cast<char*>(pSource) + 4, 4);

+            memset(reinterpret_cast<char*>(pTemp) + 12, 0xFF, 4);

+            returnType = 0;

+            break;

+        case ReturnKind::FF_Align8:

+            pTemp[0] = pSource[0];

+            pTemp[1] = pSource[1];

+            returnType = 0;

+            break;

+        case ReturnKind::FG_Align4:

+            memcpy(reinterpret_cast<char*>(pTemp), reinterpret_cast<char*>(pSource) + 4, 4);

+            memcpy(reinterpret_cast<char*>(pTemp) + 8, reinterpret_cast<char*>(pSource), 4);

+            memset(reinterpret_cast<char*>(pTemp) + 12, 0xFF, 4);

+            returnType = 1;

+            break;

+        case ReturnKind::FG_Align8:

+            pTemp[0] = pSource[1];

+            pTemp[1] = pSource[0];

+            returnType = 1;

+            break;

+        case ReturnKind::GF_Align4:

+            memcpy(reinterpret_cast<char*>(pTemp), reinterpret_cast<char*>(pSource), 4);

+            memcpy(reinterpret_cast<char*>(pTemp) + 8, reinterpret_cast<char*>(pSource) + 4, 4);

+            memset(reinterpret_cast<char*>(pTemp) + 12, 0xFF, 4);

+            returnType = 1;

+            break;

+        case ReturnKind::GF_Align8:

+            pTemp[0] = pSource[0];

+            pTemp[1] = pSource[1];

+            returnType = 1;

+            break;

+        default:

+            pTemp[0] = pSource[0];

+            pTemp[1] = pSource[1];

+            returnType = 0;

+            break;

+    }

+    pTarget[0] = pTemp[0];

+    pTarget[1] = pTemp[1];

+    free(pTemp);

+}

+

+/*

+    Extend higher bits for integer types.

+

+    According to

+    https://github.com/riscv-non-isa/riscv-elf-psabi-doc/blob/master/riscv-cc.adoc#integer-calling-convention

+

+    > When passed in registers or on the stack, integer scalars narrower than XLEN bits

+    > are widened according to the sign of their type up to 32 bits, then sign-extended

+    > to XLEN bits.

+*/

+void extIntBits(sal_uInt64* outData, const sal_uInt64* inData, bool isSigned, sal_uInt32 dataBytes)

+{

+    if (dataBytes > 8)

+    {

+        //SAL_WARN("bridges", "illegal dataBytes in dataBytes, please check the bridge.");

+        return;

+    }

+

+    sal_uInt64 data = *inData;

+    char* dataPointer = reinterpret_cast<char*>(&data);

+

+    // Clear bits which are not data

+    sal_uInt64* dataMask = (sal_uInt64*)calloc(1, 8);

+    memset(dataMask, 0xFF, dataBytes);

+    data = data & *dataMask;

+    free(dataMask);

+

+    // extend to 32 bit

+    if (dataBytes < 4)

+    {

+        if (isSigned)

+        {

+            // Detect the highest bit of the data.

+            // For example, if a one-byte integer data passed in, we need to detect the 8th bit(8 x 1)

+            // So left shift 1 three-times(8-1) we can get mask 1000 0000

+            sal_uInt64 detectMask = 1 << (dataBytes * 8 - 1);

+

+            if (detectMask & data)

+                // Is negative

+                memset(dataPointer + dataBytes, 0xFF, 4 - dataBytes);

+            else

+                // Is positive

+                memset(dataPointer + dataBytes, 0x0, 4 - dataBytes);

+        }

+        else

+            memset(dataPointer + dataBytes, 0x0, 4 - dataBytes);

+

+        // The highest data bit turns into 8 * 4 = 32 bit

+        dataBytes = 4;

+    }

+

+    // Sign extend to 64 bit

+    sal_uInt64 detectMask = 1 << (dataBytes * 8 - 1);

+    if (detectMask & data)

+        memset(dataPointer + dataBytes, 0xFF, 8 - dataBytes);

+    else

+        memset(dataPointer + dataBytes, 0x00, 8 - dataBytes);

+

+    *outData = data;

+}

 }

 

 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */

diff --git a/bridges/source/cpp_uno/gcc3_linux_riscv64/abi.hxx b/bridges/source/cpp_uno/gcc3_linux_riscv64/abi.hxx
index 081e578150e1..ea5236220a07 100644
--- a/bridges/source/cpp_uno/gcc3_linux_riscv64/abi.hxx
+++ b/bridges/source/cpp_uno/gcc3_linux_riscv64/abi.hxx
@@ -11,13 +11,24 @@
 #include <uno/data.h>

 #include <typelib/typedescription.hxx>

 

+//#define BRI_DEBUG

+

+#ifdef BRI_DEBUG

+#include <cstdio>

+#define BRIDGE_LOG(...) fprintf(stdout, __VA_ARGS__)

+#else

+#define BRIDGE_LOG(format, args...)

+#endif

+

 namespace abi_riscv64

 {

-void countnGreg(sal_Int32& nGreg, sal_Int32& nFreg,

-                const typelib_CompoundTypeDescription* pTypeDescr);

+void fillUNOStruct(const typelib_TypeDescription* pTypeDescr, sal_Int64* gret, double* fret,

+                   void* pRegisterReturn);

+

+void splitUNOStruct(const typelib_TypeDescription* pTypeDescr, sal_uInt64* pTarget,

+                    sal_uInt64* pSource, sal_Int32& returnType);

 

-void fillStruct(const typelib_TypeDescription* pTypeDescr, sal_Int64* gret, double* fret,

-                void* pRegisterReturn);

+void extIntBits(sal_uInt64* outData, const sal_uInt64* inData, bool isSigned, sal_uInt32 dataBytes);

 }

 

 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */

diff --git a/bridges/source/cpp_uno/gcc3_linux_riscv64/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_riscv64/cpp2uno.cxx
index 99965c570081..6754f23fde16 100644
--- a/bridges/source/cpp_uno/gcc3_linux_riscv64/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_riscv64/cpp2uno.cxx
@@ -34,8 +34,6 @@
 #include <cstring>
 #include <typeinfo>
 
-using namespace com::sun::star::uno;
-
 //#define BRIDGE_DEBUG
 
 #ifdef BRIDGE_DEBUG
@@ -46,6 +44,8 @@ using namespace ::osl;
 using namespace ::rtl;
 #endif
 
+using namespace com::sun::star::uno;
+
 namespace CPPU_CURRENT_NAMESPACE
 {
 bool is_complex_struct(const typelib_TypeDescription* type)
@@ -110,12 +110,10 @@ cpp2uno_call(bridges::cpp_uno::shared::CppInterfaceProxy* pThis,
            pRegisterReturn);
     printf("In cpp2uno_call, gpreg = %p, fpreg = %p, ovrflw = %p\n", gpreg, fpreg, ovrflw);
 #endif
+
     unsigned int nr_gpr = 0;
     unsigned int nr_fpr = 0;
 
-    char* gpreg_t = reinterpret_cast<char*>(gpreg);
-    char* fpreg_t = reinterpret_cast<char*>(fpreg);
-
 #ifdef BRIDGE_DEBUG
     fprintf(stdout, "cpp2uno_call:begin\n");
 #endif
@@ -151,6 +149,7 @@ cpp2uno_call(bridges::cpp_uno::shared::CppInterfaceProxy* pThis,
     }
 
     // pop this
+    // TODO: Is it really essential to pop?
     gpreg++;
     nr_gpr++;
 
@@ -344,28 +343,19 @@ cpp2uno_call(bridges::cpp_uno::shared::CppInterfaceProxy* pThis,
 
             TYPELIB_DANGER_RELEASE(pParamTypeDescr);
         }
-        void* retout = nullptr; // avoid false -Werror=maybe-uninitialized
+        //void* retout = nullptr; // avoid false -Werror=maybe-uninitialized
         // return
         sal_Int32 returnType = 0;
         if (pReturnTypeDescr)
         {
-            char* pReturn = reinterpret_cast<char*>(pRegisterReturn);
             if (!bridges::cpp_uno::shared::relatesToInterfaceType(pReturnTypeDescr))
             {
+                const bool isSigned = true;
                 switch (pReturnTypeDescr == nullptr ? typelib_TypeClass_VOID
                                                     : pReturnTypeDescr->eTypeClass)
                 {
-                    case typelib_TypeClass_HYPER:
-                    case typelib_TypeClass_UNSIGNED_HYPER:
-                    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:
-                        std::memcpy(pReturn, pUnoReturn, 8);
-                        break;
-                    // Sometimes we need to return a 32 bit integer into a 64 bit integer.
+                    // Sometimes we need to return a smaller type into a larger type.
+                    //
                     // For example, in pyuno.cxx:PyUNO_bool(), an int(32bit) is returned
                     // in type Py_ssize_t(64bit)
                     // We assume that this 32bit int was put in low 32 bit of register a0.
@@ -375,52 +365,57 @@ cpp2uno_call(bridges::cpp_uno::shared::CppInterfaceProxy* pThis,
                     // This bug occurs when build pyuno with gcc-12 with -O2.
                     // https://bugs.documentfoundation.org/show_bug.cgi?id=155937
                     //
-                    // So we need to clean the high 32 bit in bridge.
+                    // So we need to clean the higher bits in bridge.
+                    case typelib_TypeClass_BOOLEAN:
+                        abi_riscv64::extIntBits(pRegisterReturn,
+                                                reinterpret_cast<sal_uInt64*>(pUnoReturn),
+                                                !isSigned, 1);
+                        break;
+                    case typelib_TypeClass_BYTE:
+                        abi_riscv64::extIntBits(pRegisterReturn,
+                                                reinterpret_cast<sal_uInt64*>(pUnoReturn), isSigned,
+                                                1);
+                        break;
+                    case typelib_TypeClass_CHAR:
+                    case typelib_TypeClass_UNSIGNED_SHORT:
+                        abi_riscv64::extIntBits(pRegisterReturn,
+                                                reinterpret_cast<sal_uInt64*>(pUnoReturn),
+                                                !isSigned, 2);
+                        break;
+                    case typelib_TypeClass_SHORT:
+                        abi_riscv64::extIntBits(pRegisterReturn,
+                                                reinterpret_cast<sal_uInt64*>(pUnoReturn), isSigned,
+                                                2);
+                        break;
                     case typelib_TypeClass_UNSIGNED_LONG:
-                        std::memset(pReturn + 4, 0x0, 4);
-                        std::memcpy(pReturn, pUnoReturn, 4);
+                        abi_riscv64::extIntBits(pRegisterReturn,
+                                                reinterpret_cast<sal_uInt64*>(pUnoReturn),
+                                                !isSigned, 4);
                         break;
                     case typelib_TypeClass_LONG:
-                        if (*reinterpret_cast<sal_uInt32*>(pUnoReturn) & 0x80000000)
-                            std::memset(pReturn + 4, 0xFF, 4);
-                        else
-                            std::memset(pReturn + 4, 0x0, 4);
-                        std::memcpy(pReturn, pUnoReturn, 4);
+                        abi_riscv64::extIntBits(pRegisterReturn,
+                                                reinterpret_cast<sal_uInt64*>(pUnoReturn), isSigned,
+                                                4);
+                        break;
+                    // TODO: check the source of the enum type.
+                    case typelib_TypeClass_ENUM:
+                    case typelib_TypeClass_UNSIGNED_HYPER:
+                    case typelib_TypeClass_HYPER:
+                        std::memcpy(reinterpret_cast<char*>(pRegisterReturn), pUnoReturn, 8);
                         break;
                     case typelib_TypeClass_FLOAT:
-                        std::memcpy(pReturn, pUnoReturn, 4);
-                        std::memset(pReturn + 4, 0xFF, 4);
+                        std::memcpy(reinterpret_cast<char*>(pRegisterReturn), pUnoReturn, 4);
+                        std::memset(reinterpret_cast<char*>(pRegisterReturn) + 4, 0xFF, 4);
                         break;
                     case typelib_TypeClass_DOUBLE:
-                        std::memcpy(pReturn, pUnoReturn, 8);
+                        std::memcpy(reinterpret_cast<char*>(pRegisterReturn), pUnoReturn, 8);
                         break;
                     case typelib_TypeClass_STRUCT:
                     case typelib_TypeClass_EXCEPTION:
-                    {
-                        std::memcpy(pReturn, pUnoReturn, 16);
-                        sal_Int32 nGreg = 0;
-                        sal_Int32 nFreg = 0;
-                        abi_riscv64::countnGreg(
-                            nGreg, nFreg,
-                            reinterpret_cast<typelib_CompoundTypeDescription const*>(
-                                pReturnTypeDescr));
-                        if (pReturnTypeDescr->nSize <= 8 && nFreg == 2 && nGreg == 0)
-                        {
-                            std::memcpy(pReturn + 8, pReturn + 4, 4);
-                            std::memset(pReturn + 4, 0xFF, 4);
-                            std::memset(pReturn + 12, 0xFF, 4);
-                        }
-                        else if (nGreg == 1 && nFreg == 1)
-                        {
-                            returnType = 1;
-                            if (pReturnTypeDescr->nSize <= 8)
-                            {
-                                std::memcpy(pReturn + 8, pReturn + 4, 4);
-                                std::memset(pReturn + 12, 0xFF, 4);
-                            }
-                        }
-                    }
-                    break;
+                        abi_riscv64::splitUNOStruct(
+                            pReturnTypeDescr, reinterpret_cast<sal_uInt64*>(pRegisterReturn),
+                            reinterpret_cast<sal_uInt64*>(pUnoReturn), returnType);
+                        break;
                     case typelib_TypeClass_VOID:
                         break;
                     default:
@@ -595,6 +590,7 @@ sal_Int32 cpp_vtable_call(sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset, voi
                         }
                         TYPELIB_DANGER_RELEASE(pTD);
                     }
+                    [[fallthrough]];
                 } // else perform queryInterface()
                 default:
 #ifdef BRIDGE_DEBUG
@@ -722,8 +718,7 @@ unsigned char* codeSnippet(unsigned char* code, sal_Int32 functionIndex, sal_Int
 }
 }
 
-void bridges::cpp_uno::shared::VtableFactory::flushCode(unsigned char const* bptr,
-                                                        unsigned char const* eptr)
+void bridges::cpp_uno::shared::VtableFactory::flushCode(unsigned char const*, unsigned char const*)
 {
     asm volatile("fence" :::);
 }
diff --git a/bridges/source/cpp_uno/gcc3_linux_riscv64/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_linux_riscv64/uno2cpp.cxx
index a23bcc3e8cec..495fefa4d173 100644
--- a/bridges/source/cpp_uno/gcc3_linux_riscv64/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_riscv64/uno2cpp.cxx
@@ -43,105 +43,16 @@
 #include <stdio.h>
 #endif
 
-// FP reg -> GP reg -> stack
-#define INSERT_FLOAT_DOUBLE(pSV, nfr, pFPR, ngr, pGPR, pDS)                                        \
-    if (nfr < MAX_FP_REGS)                                                                         \
-        pFPR[nfr++] = *reinterpret_cast<double*>(pSV);                                             \
-    else if (ngr < MAX_FP_REGS)                                                                    \
-        pGPR[ngr++] = *reinterpret_cast<sal_Int64*>(pSV);                                          \
-    else                                                                                           \
-        *pDS++ = *reinterpret_cast<sal_uInt64*>(pSV); // verbatim!
-
-#define INSERT_INT64(pSV, nr, pGPR, pDS)                                                           \
-    if (nr < MAX_GP_REGS)                                                                          \
-        pGPR[nr++] = *reinterpret_cast<sal_Int64*>(pSV);                                           \
-    else                                                                                           \
-        *pDS++ = *reinterpret_cast<sal_Int64*>(pSV);
-
-#define INSERT_INT32(pSV, nr, pGPR, pDS)                                                           \
-    if (nr < MAX_GP_REGS)                                                                          \
-        pGPR[nr++] = *reinterpret_cast<sal_Int32*>(pSV);                                           \
-    else                                                                                           \
-        *pDS++ = *reinterpret_cast<sal_Int32*>(pSV);
-
-#define INSERT_INT16(pSV, nr, pGPR, pDS)                                                           \
-    if (nr < MAX_GP_REGS)                                                                          \
-        pGPR[nr++] = *reinterpret_cast<sal_Int16*>(pSV);                                           \
-    else                                                                                           \
-        *pDS++ = *reinterpret_cast<sal_Int16*>(pSV);
-
-#define INSERT_UINT16(pSV, nr, pGPR, pDS)                                                          \
-    if (nr < MAX_GP_REGS)                                                                          \
-        pGPR[nr++] = *reinterpret_cast<sal_uInt16*>(pSV);                                          \
-    else                                                                                           \
-        *pDS++ = *reinterpret_cast<sal_uInt16*>(pSV);
-
-#define INSERT_INT8(pSV, nr, pGPR, pDS)                                                            \
-    if (nr < MAX_GP_REGS)                                                                          \
-        pGPR[nr++] = *reinterpret_cast<sal_Int8*>(pSV);                                            \
-    else                                                                                           \
-        *pDS++ = *reinterpret_cast<sal_Int8*>(pSV);
-
 using namespace ::com::sun::star::uno;
 
 namespace
 {
-bool isReturnInFPR(const typelib_TypeDescription* pTypeDescr, sal_uInt32& nSize)
-{
-#ifdef BRIDGE_DEBUG
-    printf("In isReturnInFPR, pTypeDescr = %p, nSize = %d\n", pTypeDescr, nSize);
-#endif
-    const typelib_CompoundTypeDescription* p
-        = reinterpret_cast<const typelib_CompoundTypeDescription*>(pTypeDescr);
-
-    for (sal_Int32 i = 0; i < p->nMembers; ++i)
-    {
-        typelib_TypeDescriptionReference* pTypeInStruct = p->ppTypeRefs[i];
-
-        switch (pTypeInStruct->eTypeClass)
-        {
-            case typelib_TypeClass_STRUCT:
-            case typelib_TypeClass_EXCEPTION:
-            {
-                typelib_TypeDescription* t = 0;
-                TYPELIB_DANGER_GET(&t, pTypeInStruct);
-                bool isFPR = isReturnInFPR(t, nSize);
-                TYPELIB_DANGER_RELEASE(t);
-                if (!isFPR)
-                    return false;
-            }
-            break;
-            case typelib_TypeClass_FLOAT:
-            case typelib_TypeClass_DOUBLE:
-                if (nSize >= 16)
-                    return false;
-                nSize += 8;
-                break;
-            default:
-                return false;
-        }
-    }
-    return true;
-}
-
-void fillReturn(const typelib_TypeDescription* pTypeDescr, sal_Int64* gret, double* fret,
-                void* pRegisterReturn)
+void insertArgs(sal_uInt64 value, sal_uInt64& nGPR, sal_uInt64* pGPR, sal_uInt64*& sp)
 {
-#ifdef BRIDGE_DEBUG
-    printf("In fillReturn, pTypeDescr = %p, gret = %p, fret = %p, pRegisterReturn = %p\n",
-           pTypeDescr, gret, fret, pRegisterReturn);
-#endif
-    sal_uInt32 nSize = 0;
-    if (isReturnInFPR(pTypeDescr, nSize))
-    {
-        reinterpret_cast<double*>(pRegisterReturn)[0] = fret[0];
-        reinterpret_cast<double*>(pRegisterReturn)[1] = fret[1];
-    }
+    if (nGPR < MAX_GP_REGS)
+        pGPR[nGPR++] = value;
     else
-    {
-        reinterpret_cast<sal_Int64*>(pRegisterReturn)[0] = gret[0];
-        reinterpret_cast<sal_Int64*>(pRegisterReturn)[1] = gret[1];
-    }
+        *(sp++) = value;
 }
 
 static void callVirtualMethod(void* pAdjustedThisPtr, sal_Int32 nVtableIndex, void* pRegisterReturn,
@@ -249,7 +160,7 @@ static void callVirtualMethod(void* pAdjustedThisPtr, sal_Int32 nVtableIndex, vo
             {
                 typelib_TypeDescription* pTypeDescr = 0;
                 TYPELIB_DANGER_GET(&pTypeDescr, pReturnTypeRef);
-                abi_riscv64::fillStruct(pTypeDescr, gret, fret, pRegisterReturn);
+                abi_riscv64::fillUNOStruct(pTypeDescr, gret, fret, pRegisterReturn);
                 TYPELIB_DANGER_RELEASE(pTypeDescr);
             }
             break;
@@ -279,7 +190,7 @@ static void cpp_call(bridges::cpp_uno::shared::UnoInterfaceProxy* pThis,
     sal_uInt64* pStackStart = pStack;
 
     sal_uInt64 pGPR[MAX_GP_REGS];
-    sal_uInt64 nREG = 0;
+    sal_uInt64 nGPR = 0;
 
     double pFPR[MAX_FP_REGS];
     sal_uInt32 nFPR = 0;
@@ -304,7 +215,7 @@ static void cpp_call(bridges::cpp_uno::shared::UnoInterfaceProxy* pThis,
             pCppReturn = bridges::cpp_uno::shared::relatesToInterfaceType(pReturnTypeDescr)
                              ? __builtin_alloca(pReturnTypeDescr->nSize)
                              : pUnoReturn;
-            INSERT_INT64(&pCppReturn, nREG, pGPR, pStack);
+            pGPR[nGPR++] = reinterpret_cast<sal_uInt64>(pCppReturn);
         }
         else
         {
@@ -314,7 +225,7 @@ static void cpp_call(bridges::cpp_uno::shared::UnoInterfaceProxy* pThis,
 
     // push this
     void* pAdjustedThisPtr = reinterpret_cast<void**>(pThis->getCppI()) + aVtableSlot.offset;
-    INSERT_INT64(&pAdjustedThisPtr, nREG, pGPR, pStack);
+    pGPR[nGPR++] = reinterpret_cast<sal_uInt64>(pAdjustedThisPtr);
 
     // args
     void** pCppArgs = (void**)alloca(3 * sizeof(void*) * nParams);
@@ -351,29 +262,72 @@ static void cpp_call(bridges::cpp_uno::shared::UnoInterfaceProxy* pThis,
 #endif
             switch (pParamTypeDescr->eTypeClass)
             {
-                case typelib_TypeClass_LONG:
-                case typelib_TypeClass_UNSIGNED_LONG:
-                case typelib_TypeClass_ENUM:
-                    INSERT_INT32(pCppArgs[nPos], nREG, pGPR, pStack);
+                // In types.h:
+                // typedef unsigned char sal_Bool
+                case typelib_TypeClass_BOOLEAN:
+                    insertArgs(*static_cast<sal_Bool*>(pCppArgs[nPos]), nGPR, pGPR, pStack);
                     break;
+                case typelib_TypeClass_BYTE:
+                    insertArgs(*static_cast<sal_Int8*>(pCppArgs[nPos]), nGPR, pGPR, pStack);
+                    break;
+                // typedef sal_uInt16 sal_Unicode
                 case typelib_TypeClass_CHAR:
-                case typelib_TypeClass_SHORT:
-                    INSERT_INT16(pCppArgs[nPos], nREG, pGPR, pStack);
+                    insertArgs(*static_cast<sal_Unicode*>(pCppArgs[nPos]), nGPR, pGPR, pStack);
                     break;
                 case typelib_TypeClass_UNSIGNED_SHORT:
-                    INSERT_UINT16(pCppArgs[nPos], nREG, pGPR, pStack);
+                    insertArgs(*static_cast<sal_uInt16*>(pCppArgs[nPos]), nGPR, pGPR, pStack);
                     break;
-                case typelib_TypeClass_BOOLEAN:
-                case typelib_TypeClass_BYTE:
-                    INSERT_INT8(pCppArgs[nPos], nREG, pGPR, pStack);
+                case typelib_TypeClass_SHORT:
+                    insertArgs(*static_cast<sal_Int16*>(pCppArgs[nPos]), nGPR, pGPR, pStack);
                     break;
-                case typelib_TypeClass_FLOAT:
-                case typelib_TypeClass_DOUBLE:
-                    INSERT_FLOAT_DOUBLE(pCppArgs[nPos], nFPR, pFPR, nREG, pGPR, pStack);
+                case typelib_TypeClass_UNSIGNED_LONG:
+                    insertArgs(*static_cast<sal_uInt32*>(pCppArgs[nPos]), nGPR, pGPR, pStack);
                     break;
-                case typelib_TypeClass_HYPER:
+                case typelib_TypeClass_LONG:
+                    insertArgs(*static_cast<sal_Int32*>(pCppArgs[nPos]), nGPR, pGPR, pStack);
+                    break;
+                // Todo: what type is enum?
+                case typelib_TypeClass_ENUM:
                 case typelib_TypeClass_UNSIGNED_HYPER:
-                    INSERT_INT64(pCppArgs[nPos], nREG, pGPR, pStack);
+                    insertArgs(*static_cast<sal_uInt64*>(pCppArgs[nPos]), nGPR, pGPR, pStack);
+                    break;
+                case typelib_TypeClass_HYPER:
+                    insertArgs(*static_cast<sal_Int64*>(pCppArgs[nPos]), nGPR, pGPR, pStack);
+                    break;
+                // Floating point register -> General purpose register -> Stack
+                case typelib_TypeClass_FLOAT:
+                    char* higher32Bit;
+                    if (nFPR < MAX_FP_REGS)
+                    {
+                        higher32Bit = reinterpret_cast<char*>(&pFPR[nFPR]) + 4;
+                        std::memcpy(&(pFPR[nFPR++]), pCppArgs[nPos], 4);
+                    }
+                    else if (nGPR < MAX_GP_REGS)
+                    {
+                        higher32Bit = reinterpret_cast<char*>(&pGPR[nGPR]) + 4;
+                        std::memcpy(&(pGPR[nGPR++]), pCppArgs[nPos], 4);
+                    }
+                    else
+                    {
+                        higher32Bit = reinterpret_cast<char*>(pStack) + 4;
+                        std::memcpy(pStack++, pCppArgs[nPos], 4);
+                    }
+                    // Assure that the higher 32 bits are set to 1
+                    std::memset(higher32Bit, 0xFF, 4);
+                    break;
+                case typelib_TypeClass_DOUBLE:
+                    if (nFPR < MAX_FP_REGS)
+                    {
+                        std::memcpy(&(pFPR[nFPR++]), pCppArgs[nPos], 8);
+                    }
+                    else if (nGPR < MAX_GP_REGS)
+                    {
+                        std::memcpy(&(pGPR[nGPR++]), pCppArgs[nPos], 8);
+                    }
+                    else
+                    {
+                        std::memcpy(pStack++, pCppArgs[nPos], 8);
+                    }
                     break;
                 default:
                     break;
@@ -409,7 +363,7 @@ static void cpp_call(bridges::cpp_uno::shared::UnoInterfaceProxy* pThis,
                 // no longer needed
                 TYPELIB_DANGER_RELEASE(pParamTypeDescr);
             }
-            INSERT_INT64(&(pCppArgs[nPos]), nREG, pGPR, pStack);
+            insertArgs(reinterpret_cast<sal_uInt64>(pCppArgs[nPos]), nGPR, pGPR, pStack);
         }
     }
 
@@ -587,6 +541,7 @@ void unoInterfaceProxyDispatch(uno_Interface* pUnoI, const typelib_TypeDescripti
                         }
                         TYPELIB_DANGER_RELEASE(pTD);
                     }
+                    [[fallthrough]];
                 } // else perform queryInterface()
                 default:
                     // dependent dispatch