\r
namespace abi_riscv64\r
{\r
-void countnGreg(sal_Int32& nGreg, sal_Int32& nFreg,\r
+/*\r
+ F: floating point reg\r
+ G: general purpose reg\r
+*/\r
+enum class ReturnKind\r
+{\r
+ FF_Align4,\r
+ FF_Align8,\r
+ FG_Align4,\r
+ FG_Align8,\r
+ GF_Align4,\r
+ GF_Align8,\r
+ DEFAULT\r
+};\r
+\r
+void countnGreg(sal_Int32& nGreg, sal_Int32& nFreg, bool& firstIsGreg, sal_Int32& align,\r
const typelib_CompoundTypeDescription* pTypeDescr)\r
{\r
for (int i = 0; i < pTypeDescr->nMembers; i++)\r
typelib_TypeDescription* childTypeDescr = nullptr;\r
TYPELIB_DANGER_GET(&childTypeDescr, pTypeInStruct);\r
countnGreg(\r
- nGreg, nFreg,\r
+ nGreg, nFreg, firstIsGreg, align,\r
reinterpret_cast<typelib_CompoundTypeDescription const*>(childTypeDescr));\r
TYPELIB_DANGER_RELEASE(childTypeDescr);\r
}\r
break;\r
- case typelib_TypeClass_FLOAT:\r
case typelib_TypeClass_DOUBLE:\r
+ // Align to the larger type\r
+ align = 8;\r
+ [[fallthrough]];\r
+ case typelib_TypeClass_FLOAT:\r
nFreg++;\r
break;\r
+ case typelib_TypeClass_HYPER:\r
+ case typelib_TypeClass_UNSIGNED_HYPER:\r
+ align = 8;\r
+ [[fallthrough]];\r
default:\r
+ if (nFreg > 0)\r
+ {\r
+ firstIsGreg = false;\r
+ }\r
nGreg++;\r
break;\r
}\r
}\r
}\r
\r
-void fillStruct(const typelib_TypeDescription* pTypeDescr, sal_Int64* gret, double* fret,\r
- void* pRegisterReturn)\r
+ReturnKind getReturnKind(const typelib_TypeDescription* pTypeDescr)\r
{\r
-#ifdef BRIDGE_DEBUG\r
- printf("In fillStruct, pTypeDescr = %p, gret = %p, fret = %p, pRegisterReturn = %p\n",\r
- pTypeDescr, gret, fret, pRegisterReturn);\r
-#endif\r
sal_Int32 nGreg = 0;\r
sal_Int32 nFreg = 0;\r
- countnGreg(nGreg, nFreg, reinterpret_cast<typelib_CompoundTypeDescription const*>(pTypeDescr));\r
- char* pAdjust = reinterpret_cast<char*>(pRegisterReturn);\r
- if (nGreg == 0 && nFreg <= 2)\r
+ sal_Int32 align = 4;\r
+ bool firstIsGreg = true;\r
+ countnGreg(nGreg, nFreg, firstIsGreg, align,\r
+ reinterpret_cast<typelib_CompoundTypeDescription const*>(pTypeDescr));\r
+ if (nGreg == 0 && nFreg == 2)\r
{\r
- if (pTypeDescr->nSize <= 8 && nFreg == 2)\r
- {\r
- std::memcpy(pAdjust, fret, 4);\r
- std::memcpy(pAdjust + 4, fret + 1, 4);\r
- }\r
+ if (align == 4)\r
+ return ReturnKind::FF_Align4;\r
else\r
- {\r
- std::memcpy(pAdjust, fret, 16);\r
- }\r
+ return ReturnKind::FF_Align8;\r
}\r
- else if (nFreg == 1 && nGreg == 1)\r
+ else if (nGreg == 1 && nFreg == 1)\r
{\r
- if (pTypeDescr->nSize > 8)\r
+ if (firstIsGreg)\r
{\r
- std::memcpy(pAdjust, gret, 8);\r
- std::memcpy(pAdjust + 8, fret, 8);\r
+ if (align == 4)\r
+ return ReturnKind::GF_Align4;\r
+ else\r
+ return ReturnKind::GF_Align8;\r
}\r
else\r
{\r
- std::memcpy(pAdjust, gret, 4);\r
- std::memcpy(pAdjust + 4, fret, 4);\r
+ if (align == 4)\r
+ return ReturnKind::FG_Align4;\r
+ else\r
+ return ReturnKind::FG_Align8;\r
}\r
}\r
else\r
{\r
- std::memcpy(pAdjust, gret, 16);\r
+ return ReturnKind::DEFAULT;\r
+ }\r
+}\r
+\r
+/*\r
+ Transform the returned cpp data to uno.\r
+ This happens at the end of uno2cpp, when callee cpp func finished.\r
+\r
+ | returned data saved in\r
+ default cases | gret[0] and gret[1]\r
+ 2 float | fret[0] and fret[1]\r
+ 1 float 1 int | gret[0] and fret[0]\r
+\r
+ There is a complex problem -- alignment. For example, 4 byte float and 8 byte\r
+ integer take 16 bytes rather than 12 bytes.\r
+\r
+ There is also another complex problem. e.g. Two 4 byte integer is compacted\r
+ in a0, but two 4 byte float is seperately set in fa0 and fa1. However, return\r
+ size is 8 bytes. We need to cut the lower 32bit of fa0 and fa1 seperately and\r
+ combine them in 8 bytes.\r
+*/\r
+void fillUNOStruct(const typelib_TypeDescription* pTypeDescr, sal_Int64* gret, double* fret,\r
+ void* pRegisterReturn)\r
+{\r
+#ifdef BRIDGE_DEBUG\r
+ printf("In fillStruct, pTypeDescr = %p, gret = %p, fret = %p, pRegisterReturn = %p\n",\r
+ pTypeDescr, gret, fret, pRegisterReturn);\r
+#endif\r
+ ReturnKind returnKind = getReturnKind(pTypeDescr);\r
+ switch (returnKind)\r
+ {\r
+ case ReturnKind::FF_Align4:\r
+ memcpy(reinterpret_cast<char*>(pRegisterReturn), &(fret[0]), 4);\r
+ memcpy(reinterpret_cast<char*>(pRegisterReturn) + 4, &(fret[1]), 4);\r
+ break;\r
+ case ReturnKind::FF_Align8:\r
+ reinterpret_cast<double*>(pRegisterReturn)[0] = fret[0];\r
+ reinterpret_cast<double*>(pRegisterReturn)[1] = fret[1];\r
+ break;\r
+ case ReturnKind::FG_Align4:\r
+ memcpy(reinterpret_cast<char*>(pRegisterReturn), &(fret[0]), 4);\r
+ memcpy(reinterpret_cast<char*>(pRegisterReturn) + 4, &(gret[0]), 4);\r
+ break;\r
+ case ReturnKind::FG_Align8:\r
+ reinterpret_cast<double*>(pRegisterReturn)[0] = fret[0];\r
+ reinterpret_cast<sal_Int64*>(pRegisterReturn)[1] = gret[0];\r
+ break;\r
+ case ReturnKind::GF_Align4:\r
+ memcpy(reinterpret_cast<char*>(pRegisterReturn), &(gret[0]), 4);\r
+ memcpy(reinterpret_cast<char*>(pRegisterReturn) + 4, &(fret[0]), 4);\r
+ break;\r
+ case ReturnKind::GF_Align8:\r
+ reinterpret_cast<sal_Int64*>(pRegisterReturn)[0] = gret[0];\r
+ reinterpret_cast<double*>(pRegisterReturn)[1] = fret[0];\r
+ break;\r
+ default:\r
+ reinterpret_cast<sal_Int64*>(pRegisterReturn)[0] = gret[0];\r
+ reinterpret_cast<sal_Int64*>(pRegisterReturn)[1] = gret[1];\r
+ break;\r
}\r
}\r
+\r
+/*\r
+ Split zipped unoreturn to cpp func. This happens at the end of cpp2uno.\r
+\r
+ The data in pTarget will be extrat to return regs in privateSnippetExecutor:\r
+ | pTarget[0] | pTarget[1] | return type |\r
+ default cases | $a0 | $a1 | 0 |\r
+ 2 float | $fa0 | $fa1 | 0 |\r
+ 1 float 1 int | $a0 | $fa0 | 1 |\r
+\r
+ This looks like a reverse version of fillUNOStruct. The reason for such\r
+ "meaningless" effort is that java return a compact struct, but cpp not.\r
+*/\r
+void splitUNOStruct(const typelib_TypeDescription* pTypeDescr, sal_uInt64* pTarget,\r
+ sal_uInt64* pSource, sal_Int32& returnType)\r
+{\r
+#ifdef BRIDGE_DEBUG\r
+ printf("In splitUNOStruct, pTypeDescr = %p, pTarget = %p, pSource = %p\n", pTypeDescr, pTarget,\r
+ pSource);\r
+#endif\r
+ sal_uInt64* pTemp = (sal_uInt64*)calloc(2, sizeof(sal_uInt64));\r
+ ReturnKind returnKind = getReturnKind(pTypeDescr);\r
+ switch (returnKind)\r
+ {\r
+ case ReturnKind::FF_Align4:\r
+ memcpy(reinterpret_cast<char*>(pTemp), reinterpret_cast<char*>(pSource), 4);\r
+ memset(reinterpret_cast<char*>(pTemp) + 4, 0xFF, 4);\r
+ memcpy(reinterpret_cast<char*>(pTemp) + 8, reinterpret_cast<char*>(pSource) + 4, 4);\r
+ memset(reinterpret_cast<char*>(pTemp) + 12, 0xFF, 4);\r
+ returnType = 0;\r
+ break;\r
+ case ReturnKind::FF_Align8:\r
+ pTemp[0] = pSource[0];\r
+ pTemp[1] = pSource[1];\r
+ returnType = 0;\r
+ break;\r
+ case ReturnKind::FG_Align4:\r
+ memcpy(reinterpret_cast<char*>(pTemp), reinterpret_cast<char*>(pSource) + 4, 4);\r
+ memcpy(reinterpret_cast<char*>(pTemp) + 8, reinterpret_cast<char*>(pSource), 4);\r
+ memset(reinterpret_cast<char*>(pTemp) + 12, 0xFF, 4);\r
+ returnType = 1;\r
+ break;\r
+ case ReturnKind::FG_Align8:\r
+ pTemp[0] = pSource[1];\r
+ pTemp[1] = pSource[0];\r
+ returnType = 1;\r
+ break;\r
+ case ReturnKind::GF_Align4:\r
+ memcpy(reinterpret_cast<char*>(pTemp), reinterpret_cast<char*>(pSource), 4);\r
+ memcpy(reinterpret_cast<char*>(pTemp) + 8, reinterpret_cast<char*>(pSource) + 4, 4);\r
+ memset(reinterpret_cast<char*>(pTemp) + 12, 0xFF, 4);\r
+ returnType = 1;\r
+ break;\r
+ case ReturnKind::GF_Align8:\r
+ pTemp[0] = pSource[0];\r
+ pTemp[1] = pSource[1];\r
+ returnType = 1;\r
+ break;\r
+ default:\r
+ pTemp[0] = pSource[0];\r
+ pTemp[1] = pSource[1];\r
+ returnType = 0;\r
+ break;\r
+ }\r
+ pTarget[0] = pTemp[0];\r
+ pTarget[1] = pTemp[1];\r
+ free(pTemp);\r
+}\r
+\r
+/*\r
+ Extend higher bits for integer types.\r
+\r
+ According to\r
+ https://github.com/riscv-non-isa/riscv-elf-psabi-doc/blob/master/riscv-cc.adoc#integer-calling-convention\r
+\r
+ > When passed in registers or on the stack, integer scalars narrower than XLEN bits\r
+ > are widened according to the sign of their type up to 32 bits, then sign-extended\r
+ > to XLEN bits.\r
+*/\r
+void extIntBits(sal_uInt64* outData, const sal_uInt64* inData, bool isSigned, sal_uInt32 dataBytes)\r
+{\r
+ if (dataBytes > 8)\r
+ {\r
+ //SAL_WARN("bridges", "illegal dataBytes in dataBytes, please check the bridge.");\r
+ return;\r
+ }\r
+\r
+ sal_uInt64 data = *inData;\r
+ char* dataPointer = reinterpret_cast<char*>(&data);\r
+\r
+ // Clear bits which are not data\r
+ sal_uInt64* dataMask = (sal_uInt64*)calloc(1, 8);\r
+ memset(dataMask, 0xFF, dataBytes);\r
+ data = data & *dataMask;\r
+ free(dataMask);\r
+\r
+ // extend to 32 bit\r
+ if (dataBytes < 4)\r
+ {\r
+ if (isSigned)\r
+ {\r
+ // Detect the highest bit of the data.\r
+ // For example, if a one-byte integer data passed in, we need to detect the 8th bit(8 x 1)\r
+ // So left shift 1 three-times(8-1) we can get mask 1000 0000\r
+ sal_uInt64 detectMask = 1 << (dataBytes * 8 - 1);\r
+\r
+ if (detectMask & data)\r
+ // Is negative\r
+ memset(dataPointer + dataBytes, 0xFF, 4 - dataBytes);\r
+ else\r
+ // Is positive\r
+ memset(dataPointer + dataBytes, 0x0, 4 - dataBytes);\r
+ }\r
+ else\r
+ memset(dataPointer + dataBytes, 0x0, 4 - dataBytes);\r
+\r
+ // The highest data bit turns into 8 * 4 = 32 bit\r
+ dataBytes = 4;\r
+ }\r
+\r
+ // Sign extend to 64 bit\r
+ sal_uInt64 detectMask = 1 << (dataBytes * 8 - 1);\r
+ if (detectMask & data)\r
+ memset(dataPointer + dataBytes, 0xFF, 8 - dataBytes);\r
+ else\r
+ memset(dataPointer + dataBytes, 0x00, 8 - dataBytes);\r
+\r
+ *outData = data;\r
+}\r
}\r
\r
/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */\r
#include <uno/data.h>\r
#include <typelib/typedescription.hxx>\r
\r
+//#define BRI_DEBUG\r
+\r
+#ifdef BRI_DEBUG\r
+#include <cstdio>\r
+#define BRIDGE_LOG(...) fprintf(stdout, __VA_ARGS__)\r
+#else\r
+#define BRIDGE_LOG(format, args...)\r
+#endif\r
+\r
namespace abi_riscv64\r
{\r
-void countnGreg(sal_Int32& nGreg, sal_Int32& nFreg,\r
- const typelib_CompoundTypeDescription* pTypeDescr);\r
+void fillUNOStruct(const typelib_TypeDescription* pTypeDescr, sal_Int64* gret, double* fret,\r
+ void* pRegisterReturn);\r
+\r
+void splitUNOStruct(const typelib_TypeDescription* pTypeDescr, sal_uInt64* pTarget,\r
+ sal_uInt64* pSource, sal_Int32& returnType);\r
\r
-void fillStruct(const typelib_TypeDescription* pTypeDescr, sal_Int64* gret, double* fret,\r
- void* pRegisterReturn);\r
+void extIntBits(sal_uInt64* outData, const sal_uInt64* inData, bool isSigned, sal_uInt32 dataBytes);\r
}\r
\r
/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */\r
#include <cstring>
#include <typeinfo>
-using namespace com::sun::star::uno;
-
//#define BRIDGE_DEBUG
#ifdef BRIDGE_DEBUG
using namespace ::rtl;
#endif
+using namespace com::sun::star::uno;
+
namespace CPPU_CURRENT_NAMESPACE
{
bool is_complex_struct(const typelib_TypeDescription* type)
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
}
// pop this
+ // TODO: Is it really essential to pop?
gpreg++;
nr_gpr++;
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.
// 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:
}
TYPELIB_DANGER_RELEASE(pTD);
}
+ [[fallthrough]];
} // else perform queryInterface()
default:
#ifdef BRIDGE_DEBUG
}
}
-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" :::);
}
#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,
{
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;
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;
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
{
// 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);
#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;
// no longer needed
TYPELIB_DANGER_RELEASE(pParamTypeDescr);
}
- INSERT_INT64(&(pCppArgs[nPos]), nREG, pGPR, pStack);
+ insertArgs(reinterpret_cast<sal_uInt64>(pCppArgs[nPos]), nGPR, pGPR, pStack);
}
}
}
TYPELIB_DANGER_RELEASE(pTD);
}
+ [[fallthrough]];
} // else perform queryInterface()
default:
// dependent dispatch
projects / libreoffice.git / commitdiff