#include <algorithm>
|
#include "PlatformInvoke.h"
|
|
#include "il2cpp-mono-support.h"
|
#include "il2cpp-mapping.h"
|
#include "il2cpp-metadata.h"
|
#include "utils/StringUtils.h"
|
#include "vm-utils/NativeDelegateMethodCache.h"
|
#include "mono-api.h"
|
#include "MetadataCache.h"
|
|
extern const Il2CppCodeRegistration g_CodeRegistration IL2CPP_ATTRIBUTE_WEAK;
|
|
namespace mono
|
{
|
namespace vm
|
{
|
static mono_unichar2* GetFirstElementAddress(MonoArray *array)
|
{
|
return reinterpret_cast<mono_unichar2*>(reinterpret_cast<char*>(array) + kIl2CppSizeOfArray);
|
}
|
|
char* PlatformInvoke::MarshalCSharpStringToCppString(MonoString* managedString)
|
{
|
if (managedString == NULL)
|
return NULL;
|
|
char *utf8String = mono_string_to_utf8(managedString);
|
|
char* nativeString = MarshalAllocateStringBuffer<char>(mono_string_length(managedString) + 1);
|
strcpy(nativeString, utf8String);
|
mono_unity_g_free(utf8String);
|
|
return nativeString;
|
}
|
|
void PlatformInvoke::MarshalCSharpStringToCppStringFixed(MonoString* managedString, char* buffer, int numberOfCharacters)
|
{
|
if (managedString == NULL)
|
{
|
*buffer = '\0';
|
}
|
else
|
{
|
char *utf8String = mono_string_to_utf8(managedString);
|
strncpy(buffer, utf8String, numberOfCharacters - 1);
|
mono_unity_g_free(utf8String);
|
}
|
}
|
|
mono_unichar2* PlatformInvoke::MarshalCSharpStringToCppWString(MonoString* managedString)
|
{
|
if (managedString == NULL)
|
return NULL;
|
|
int stringLength = mono_string_length(managedString);
|
mono_unichar2* nativeString = MarshalAllocateStringBuffer<mono_unichar2>(stringLength + 1);
|
for (int32_t i = 0; i < stringLength; ++i)
|
nativeString[i] = managedString->chars[i];
|
|
nativeString[managedString->length] = '\0';
|
|
return nativeString;
|
}
|
|
void PlatformInvoke::MarshalCSharpStringToCppWStringFixed(MonoString* managedString, mono_unichar2* buffer, int numberOfCharacters)
|
{
|
if (managedString == NULL)
|
{
|
*buffer = '\0';
|
}
|
else
|
{
|
int32_t stringLength = std::min(mono_string_length(managedString), numberOfCharacters - 1);
|
for (int32_t i = 0; i < stringLength; ++i)
|
buffer[i] = managedString->chars[i];
|
|
buffer[stringLength] = '\0';
|
}
|
}
|
|
MonoString* PlatformInvoke::MarshalCppStringToCSharpStringResult(const char* value)
|
{
|
if (value == NULL)
|
return NULL;
|
|
return mono_string_new(g_MonoDomain, value);
|
}
|
|
MonoString* PlatformInvoke::MarshalCppWStringToCSharpStringResult(const mono_unichar2* value)
|
{
|
if (value == NULL)
|
return NULL;
|
|
return mono_string_new_utf16(g_MonoDomain, value, (int)il2cpp::utils::StringUtils::StrLen(value));
|
}
|
|
char* PlatformInvoke::MarshalEmptyStringBuilder(MonoStringBuilder* stringBuilder, size_t& stringLength, std::vector<std::string>& utf8Chunks, std::vector<MonoStringBuilder*>& builders)
|
{
|
if (stringBuilder == NULL)
|
return NULL;
|
|
stringLength = 0;
|
MonoStringBuilder* currentBuilder = stringBuilder;
|
|
while (true)
|
{
|
if (currentBuilder == NULL)
|
break;
|
|
const mono_unichar2 *str = GetFirstElementAddress(currentBuilder->chunkChars);
|
std::string utf8String = il2cpp::utils::StringUtils::Utf16ToUtf8((Il2CppChar*)str, (int)currentBuilder->chunkChars->max_length);
|
|
utf8Chunks.push_back(utf8String);
|
builders.push_back(currentBuilder);
|
|
size_t lenToCount = std::max((size_t)currentBuilder->chunkChars->max_length, utf8String.size());
|
|
stringLength += lenToCount;
|
|
currentBuilder = currentBuilder->chunkPrevious;
|
}
|
|
char* nativeString = MarshalAllocateStringBuffer<char>(stringLength + 1);
|
|
// We need to zero out the memory because the chunkChar array lengh may have been larger than the chunkLength
|
// and when this happens we'll have a utf8String that is smaller than the the nativeString we allocated. When we go to copy the
|
// chunk utf8String into the nativeString it won't fill everything and we can end up with w/e junk value was in that memory before
|
memset(nativeString, 0, sizeof(char) * (stringLength + 1));
|
|
return nativeString;
|
}
|
|
char* PlatformInvoke::MarshalEmptyStringBuilder(MonoStringBuilder* stringBuilder)
|
{
|
size_t sizeLength;
|
std::vector<std::string> utf8Chunks;
|
std::vector<MonoStringBuilder*> builders;
|
return MarshalEmptyStringBuilder(stringBuilder, sizeLength, utf8Chunks, builders);
|
}
|
|
char* PlatformInvoke::MarshalStringBuilder(MonoStringBuilder* stringBuilder)
|
{
|
if (stringBuilder == NULL)
|
return NULL;
|
|
size_t stringLength;
|
std::vector<std::string> utf8Chunks;
|
std::vector<MonoStringBuilder*> builders;
|
char* nativeString = MarshalEmptyStringBuilder(stringBuilder, stringLength, utf8Chunks, builders);
|
|
if (stringLength > 0)
|
{
|
int offsetAdjustment = 0;
|
for (int i = (int)utf8Chunks.size() - 1; i >= 0; i--)
|
{
|
std::string utf8String = utf8Chunks[i];
|
|
const char* utf8CString = utf8String.c_str();
|
|
memcpy(nativeString + builders[i]->chunkOffset + offsetAdjustment, utf8CString, (int)utf8String.size());
|
|
offsetAdjustment += (int)utf8String.size() - builders[i]->chunkLength;
|
}
|
}
|
|
return nativeString;
|
}
|
|
mono_unichar2* PlatformInvoke::MarshalEmptyWStringBuilder(MonoStringBuilder* stringBuilder, size_t& stringLength)
|
{
|
if (stringBuilder == NULL)
|
return NULL;
|
|
stringLength = 0;
|
MonoStringBuilder* currentBuilder = stringBuilder;
|
while (true)
|
{
|
if (currentBuilder == NULL)
|
break;
|
|
stringLength += (size_t)currentBuilder->chunkChars->max_length;
|
|
currentBuilder = currentBuilder->chunkPrevious;
|
}
|
|
return MarshalAllocateStringBuffer<mono_unichar2>(stringLength + 1);
|
}
|
|
mono_unichar2* PlatformInvoke::MarshalEmptyWStringBuilder(MonoStringBuilder* stringBuilder)
|
{
|
size_t stringLength;
|
return MarshalEmptyWStringBuilder(stringBuilder, stringLength);
|
}
|
|
mono_unichar2* PlatformInvoke::MarshalWStringBuilder(MonoStringBuilder* stringBuilder)
|
{
|
if (stringBuilder == NULL)
|
return NULL;
|
|
size_t stringLength;
|
mono_unichar2* nativeString = MarshalEmptyWStringBuilder(stringBuilder, stringLength);
|
|
if (stringLength > 0)
|
{
|
MonoStringBuilder* currentBuilder = stringBuilder;
|
while (true)
|
{
|
if (currentBuilder == NULL)
|
break;
|
|
const mono_unichar2 *str = GetFirstElementAddress(currentBuilder->chunkChars);
|
|
memcpy(nativeString + currentBuilder->chunkOffset, str, (int)currentBuilder->chunkChars->max_length * sizeof(mono_unichar2));
|
|
currentBuilder = currentBuilder->chunkPrevious;
|
}
|
}
|
|
nativeString[stringLength] = '\0';
|
|
return nativeString;
|
}
|
|
void PlatformInvoke::MarshalStringBuilderResult(MonoStringBuilder* stringBuilder, char* buffer)
|
{
|
if (stringBuilder == NULL || buffer == NULL)
|
return;
|
|
UTF16String utf16String = il2cpp::utils::StringUtils::Utf8ToUtf16(buffer);
|
|
MONO_OBJECT_SETREF(stringBuilder, chunkChars, MonoArrayNew(mono_unity_defaults_get_char_class(), (int)utf16String.size() + 1));
|
|
for (int i = 0; i < (int)utf16String.size(); i++)
|
mono_array_set(stringBuilder->chunkChars, mono_unichar2, i, utf16String[i]);
|
|
mono_array_set(stringBuilder->chunkChars, mono_unichar2, (int)utf16String.size(), '\0');
|
|
stringBuilder->chunkLength = (int)utf16String.size();
|
stringBuilder->chunkOffset = 0;
|
MONO_OBJECT_SETREF(stringBuilder, chunkPrevious, NULL);
|
}
|
|
void PlatformInvoke::MarshalWStringBuilderResult(MonoStringBuilder* stringBuilder, mono_unichar2* buffer)
|
{
|
if (stringBuilder == NULL || buffer == NULL)
|
return;
|
|
int len = (int)il2cpp::utils::StringUtils::StrLen(buffer);
|
|
MONO_OBJECT_SETREF(stringBuilder, chunkChars, MonoArrayNew(mono_unity_defaults_get_char_class(), len + 1));
|
|
for (int i = 0; i < len; i++)
|
mono_array_set(stringBuilder->chunkChars, mono_unichar2, i, buffer[i]);
|
|
mono_array_set(stringBuilder->chunkChars, mono_unichar2, len, '\0');
|
|
stringBuilder->chunkLength = len;
|
stringBuilder->chunkOffset = 0;
|
MONO_OBJECT_SETREF(stringBuilder, chunkPrevious, NULL);
|
}
|
|
static int CompareIl2CppTokenIndexMethodTuple(const void* pkey, const void* pelem)
|
{
|
return (int)(((Il2CppTokenIndexMethodTuple*)pkey)->token - ((Il2CppTokenIndexMethodTuple*)pelem)->token);
|
}
|
|
static Il2CppMethodPointer GetReversePInvokeWrapperFromIndex(MonoMethod* method)
|
{
|
Il2CppCodeGenModule* codeGenModule = InitializeCodeGenHandle(method->klass->image);
|
|
if (codeGenModule->reversePInvokeWrapperCount == 0)
|
return NULL;
|
|
Il2CppTokenIndexMethodTuple key;
|
memset(&key, 0, sizeof(Il2CppTokenIndexMethodTuple));
|
key.token = method->token;
|
|
const Il2CppTokenIndexMethodTuple* res = (const Il2CppTokenIndexMethodTuple*)bsearch(&key, codeGenModule->reversePInvokeWrapperIndices, codeGenModule->reversePInvokeWrapperCount, sizeof(Il2CppTokenIndexMethodTuple), CompareIl2CppTokenIndexMethodTuple);
|
|
if (res == NULL)
|
return NULL;
|
|
uint32_t index = res->index;
|
|
assert(index < g_CodeRegistration.reversePInvokeWrapperCount);
|
return g_CodeRegistration.reversePInvokeWrappers[index];
|
}
|
|
intptr_t PlatformInvoke::MarshalDelegate(MonoDelegate* d)
|
{
|
if (d == NULL)
|
return 0;
|
|
if (unity_mono_method_is_inflated(d->method))
|
mono_raise_exception(mono_get_exception_not_supported("IL2CPP does not support marshaling delegates that point to generic methods."));
|
|
Il2CppMethodPointer reversePInvokeWrapper = GetReversePInvokeWrapperFromIndex((MonoMethod*)d->method);
|
if (reversePInvokeWrapper == NULL)
|
{
|
// Okay, we cannot marshal it for some reason. Figure out why.
|
if (mono_signature_is_instance(mono_method_signature((MonoMethod*)d->method)))
|
mono_raise_exception(mono_get_exception_not_supported("IL2CPP does not support marshaling delegates that point to instance methods to native code."));
|
|
mono_raise_exception(mono_get_exception_not_supported("To marshal a managed method, please add an attribute named 'MonoPInvokeCallback' to the method definition."));
|
}
|
|
return reinterpret_cast<intptr_t>(reversePInvokeWrapper);
|
}
|
|
Il2CppDelegate* PlatformInvoke::MarshalFunctionPointerToDelegate(void* functionPtr, MonoClass* delegateType)
|
{
|
if (!mono_unity_class_has_parent_unsafe(delegateType, mono_unity_defaults_get_delegate_class()))
|
mono_raise_exception(mono_get_exception_argument("t", "Type must derive from Delegate."));
|
|
if (mono_class_is_generic(delegateType) || mono_class_is_inflated(delegateType))
|
mono_raise_exception(mono_get_exception_argument("t", "The specified Type must not be a generic type definition."));
|
|
const Il2CppInteropData* interopData = FindInteropDataFor(delegateType);
|
Il2CppMethodPointer managedToNativeWrapperMethodPointer = interopData != NULL ? interopData->delegatePInvokeWrapperFunction : NULL;
|
|
if (managedToNativeWrapperMethodPointer == NULL)
|
mono_raise_exception(mono_unity_exception_get_marshal_directive(il2cpp::utils::StringUtils::Printf("Cannot marshal P/Invoke call through delegate of type '%s.%s'", mono_class_get_namespace(delegateType), mono_class_get_name(delegateType)).c_str()));
|
|
MonoObject* delegate = mono_object_new(g_MonoDomain, delegateType);
|
Il2CppMethodPointer nativeFunctionPointer = (Il2CppMethodPointer)functionPtr;
|
|
const MonoMethod* method = il2cpp::utils::NativeDelegateMethodCache::GetNativeDelegate(nativeFunctionPointer);
|
if (method == NULL)
|
{
|
MonoMethod* newMethod = mono_unity_method_delegate_invoke_wrapper(delegateType);
|
mono_unity_method_set_method_pointer(newMethod, (void*)nativeFunctionPointer);
|
mono_unity_method_set_invoke_pointer(newMethod, NULL);
|
il2cpp::utils::NativeDelegateMethodCache::AddNativeDelegate(nativeFunctionPointer, newMethod);
|
method = newMethod;
|
}
|
|
MonoError unused;
|
// FIXME: do we need to free these handles?
|
MonoObjectHandle thisHandle = MONO_HANDLE_NEW(MonoObject, (MonoObject*)delegate);
|
MonoObjectHandle targetHandle = MONO_HANDLE_NEW(MonoObject, (MonoObject*)delegate);
|
gboolean success = mono_delegate_ctor_with_method(thisHandle, targetHandle, (void*)managedToNativeWrapperMethodPointer, const_cast<MonoMethod*>(method), &unused);
|
|
return (Il2CppDelegate*)delegate;
|
}
|
} // namespace vm
|
} // namespace mono
|
