#include "il2cpp-config.h"

#include "metadata/GenericMethod.h"

#include "os/CrashHelpers.h"

#include "os/Environment.h"

#include "os/File.h"

#include "os/Image.h"

#include "os/Initialize.h"

#include "os/LibraryLoader.h"

#include "os/Locale.h"

#include "os/MemoryMappedFile.h"

#include "os/Mutex.h"

#include "os/Path.h"

#include "os/SynchronizationContext.h"

#include "os/Thread.h"

#include "os/Socket.h"

#include "os/c-api/Allocator.h"

#include "metadata/GenericMetadata.h"

#include "vm/Array.h"

#include "vm/Assembly.h"

#include "vm/ClassLibraryPAL.h"

#include "vm/COMEntryPoints.h"

#include "vm/Class.h"

#include "vm/Domain.h"

#include "vm/Exception.h"

#include "vm/Field.h"

#include "gc/GCHandle.h"

#include "vm/Image.h"

#include "vm/LastError.h"

#include "vm/MetadataAlloc.h"

#include "vm/MetadataCache.h"

#include "vm/MetadataLock.h"

#include "vm/Method.h"

#include "vm/Reflection.h"

#include "vm/Runtime.h"

#include "vm/Thread.h"

#include "vm/Type.h"

#include "vm/StackTrace.h"

#include "vm/String.h"

#include "vm/Object.h"

#include "vm-utils/Debugger.h"

#include "vm-utils/DebugSymbolReader.h"

#include "vm/Profiler.h"

#include "utils/Logging.h"

#include <string>

#include <map>

#include "il2cpp-class-internals.h"

#include "il2cpp-object-internals.h"

#include "il2cpp-tabledefs.h"

#include "gc/GarbageCollector.h"

#include "gc/WriteBarrier.h"

#include "vm/InternalCalls.h"

#include "utils/Collections.h"

#include "utils/Memory.h"

#include "utils/StringUtils.h"

#include "utils/PathUtils.h"

#include "utils/Runtime.h"

#include "utils/Environment.h"

#include "mono/ThreadPool/threadpool-ms.h"

#include "mono/ThreadPool/threadpool-ms-io.h"

#include "icalls/mscorlib/System.Reflection/RuntimeAssembly.h"

#include "icalls/mscorlib/System.IO/MonoIO.h"

#include "vm/Monitor.h"

#include "vm-utils/Debugger.h"

#include "Baselib.h"

#include "Cpp/ReentrantLock.h"

#include "hybridclr/Runtime.h"

#include "hybridclr/Il2CppCompatibleDef.h"

Il2CppDefaults il2cpp_defaults;

bool g_il2cpp_is_fully_initialized = false;

static bool shutting_down = false;

MetadataInitializerCleanupFunc g_ClearMethodMetadataInitializedFlags = NULL;

static baselib::ReentrantLock s_InitLock;

static int32_t s_RuntimeInitCount;

typedef void (*CodegenRegistrationFunction) ();

extern CodegenRegistrationFunction g_CodegenRegistration;

namespace il2cpp

{

namespace vm

{

baselib::ReentrantLock g_MetadataLock;

static int32_t exitcode = 0;

static std::string s_ConfigDir;

static const char *s_FrameworkVersion = 0;

static const char *s_BundledMachineConfig = 0;

static Il2CppRuntimeUnhandledExceptionPolicy s_UnhandledExceptionPolicy = IL2CPP_UNHANDLED_POLICY_CURRENT;

static const void* s_UnitytlsInterface = NULL;

#define DEFAULTS_INIT(field, ns, n) do { il2cpp_defaults.field = Class::FromName (il2cpp_defaults.corlib, ns, n);\

IL2CPP_ASSERT(il2cpp_defaults.field); } while (0)

#define DEFAULTS_INIT_TYPE(field, ns, n, nativetype) do { DEFAULTS_INIT(field, ns, n); \

IL2CPP_ASSERT(il2cpp_defaults.field->instance_size == sizeof(nativetype) + (il2cpp_defaults.field->byval_arg.valuetype ? sizeof(Il2CppObject) : 0)); } while (0)

#define DEFAULTS_INIT_OPTIONAL(field, ns, n) do { il2cpp_defaults.field = Class::FromName (il2cpp_defaults.corlib, ns, n); } while (0)

#define DEFAULTS_INIT_TYPE_OPTIONAL(field, ns, n, nativetype) do { DEFAULTS_INIT_OPTIONAL(field, ns, n); \

if (il2cpp_defaults.field != NULL) \

IL2CPP_ASSERT(il2cpp_defaults.field->instance_size == sizeof(nativetype) + (il2cpp_defaults.field->byval_arg.valuetype ? sizeof(Il2CppObject) : 0)); } while (0)

#define DEFAULTS_GEN_INIT(field, ns, n) do { il2cpp_defaults.field = Class::FromName (il2cpp_defaults.corlib_gen, ns, n);\

IL2CPP_ASSERT(il2cpp_defaults.field); } while (0)

#define DEFAULTS_GEN_INIT_TYPE(field, ns, n, nativetype) do { DEFAULTS_GEN_INIT(field, ns, n); \

IL2CPP_ASSERT(il2cpp_defaults.field->instance_size == sizeof(nativetype) + (il2cpp_defaults.field->byval_arg.valuetype ? sizeof(Il2CppObject) : 0)); } while (0)

#define DEFAULTS_GEN_INIT_OPTIONAL(field, ns, n) do { il2cpp_defaults.field = Class::FromName (il2cpp_defaults.corlib_gen, ns, n); } while (0)

char* basepath(const char* path)

{

std::string original_path(path);

size_t position_of_last_separator = original_path.find_last_of(IL2CPP_DIR_SEPARATOR);

return il2cpp::utils::StringUtils::StringDuplicate(original_path.substr(position_of_last_separator + 1).c_str());

}

static const char *framework_version_for(const char *runtime_version)

{

IL2CPP_ASSERT(runtime_version && "Invalid runtime version");

IL2CPP_ASSERT((strstr(runtime_version, "v4.0") == runtime_version) && "Invalid runtime version");

return "4.0";

}

static void SanityChecks()

}

static inline void InitializeStringEmpty()

}

static void SetConfigStr(const std::string& executablePath);

bool Runtime::Init(const char* domainName)

}

static Il2CppObject* GetEventArgsEmptyField()

{

Il2CppClass* eventArgsKlass = Class::FromName(il2cpp_defaults.corlib, "System", "EventArgs");

if (eventArgsKlass != NULL)

{

Class::Init(eventArgsKlass);

FieldInfo* emptyField = vm::Class::GetFieldFromName(eventArgsKlass, "Empty");

if (emptyField != NULL)

{

Il2CppObject* emptyValue;

vm::Field::StaticGetValue(emptyField, &emptyValue);

return emptyValue;

}

}

return NULL;

}

static void FireProcessExitEvent()

}

void Runtime::Shutdown()

}

bool Runtime::IsShuttingDown()

{

return shutting_down;

}

void Runtime::SetConfigDir(const char *path)

{

s_ConfigDir = path;

}

static void SetConfigStr(const std::string& executablePath)

}

void Runtime::SetConfigUtf16(const Il2CppChar* executablePath)

}

void Runtime::SetConfig(const char* executablePath)

}

void Runtime::SetUnityTlsInterface(const void* unitytlsInterface)

{

s_UnitytlsInterface = unitytlsInterface;

}

const char *Runtime::GetFrameworkVersion()

{

return s_FrameworkVersion;

}

std::string Runtime::GetConfigDir()

}

const void* Runtime::GetUnityTlsInterface()

{

return s_UnitytlsInterface;

}

const MethodInfo* Runtime::GetDelegateInvoke(Il2CppClass* klass)

{

const MethodInfo* invoke = Class::GetMethodFromName(klass, "Invoke", -1);

IL2CPP_ASSERT(invoke);

return invoke;

}

Il2CppObject* Runtime::DelegateInvoke(Il2CppDelegate *delegate, void **params, Il2CppException **exc)

{

const MethodInfo* invoke = GetDelegateInvoke(delegate->object.klass);

return Invoke(invoke, delegate, params, exc);

}

Il2CppObject* Runtime::Invoke(const MethodInfo *method, void *obj, void **params, Il2CppException **exc)

{

if (exc)

il2cpp::gc::WriteBarrier::GenericStoreNull(exc);

// we wrap invoker call in try/catch here, rather than emitting a try/catch

// in every invoke call as that blows up the code size.

try

{

if ((method->flags & METHOD_ATTRIBUTE_STATIC) && method->klass && !method->klass->cctor_finished_or_no_cctor)

ClassInit(method->klass);

return InvokeWithThrow(method, obj, params);

}

catch (Il2CppExceptionWrapper& ex)

{

if (exc)

il2cpp::gc::WriteBarrier::GenericStore(exc, ex.ex);

return NULL;

}

}

Il2CppObject* Runtime::InvokeWithThrow(const MethodInfo *method, void *obj, void **params)

{

hybridclr::InitAndGetInterpreterDirectlyCallMethodPointer(method);

if (method->return_type->type == IL2CPP_TYPE_VOID)

{

method->invoker_method(method->methodPointer, method, obj, params, NULL);

return NULL;

}

else

{

if (method->return_type->valuetype)

{

Il2CppClass* returnType = Class::FromIl2CppType(method->return_type);

Class::Init(returnType);

void* returnValue = alloca(returnType->instance_size - sizeof(Il2CppObject));

method->invoker_method(method->methodPointer, method, obj, params, returnValue);

return Object::Box(returnType, returnValue);

}

else

{

// Note that here method->return_type might be a reference type or it might be

// a value type returned by reference.

void* returnValue = NULL;

method->invoker_method(method->methodPointer, method, obj, params, &returnValue);

if (method->return_type->byref)

{

// We cannot use method->return_type->valuetype here, because that will be

// false for methods that return by reference. Instead, get the class for the

// type, which discards the byref flag.

Il2CppClass* returnType = Class::FromIl2CppType(method->return_type);

if (vm::Class::IsValuetype(returnType))

return Object::Box(returnType, returnValue);

return *(Il2CppObject**)returnValue;

}

return (Il2CppObject*)returnValue;

}

}

}

Il2CppObject* Runtime::InvokeArray(const MethodInfo *method, void *obj, Il2CppArray *params, Il2CppException **exc)

{

if (params == NULL)

return InvokeConvertArgs(method, obj, NULL, 0, exc);

// TO DO: when changing GC to one that moves managed objects around, mark params array local variable as pinned!

return InvokeConvertArgs(method, obj, reinterpret_cast<Il2CppObject**>(Array::GetFirstElementAddress(params)), Array::GetLength(params), exc);

}

void Runtime::ObjectInit(Il2CppObject *object)

{

ObjectInitException(object, NULL);

}

void Runtime::ObjectInitException(Il2CppObject *object, Il2CppException **exc)

}

void Runtime::SetUnhandledExceptionPolicy(Il2CppRuntimeUnhandledExceptionPolicy value)

{

s_UnhandledExceptionPolicy = value;

}

Il2CppRuntimeUnhandledExceptionPolicy Runtime::GetUnhandledExceptionPolicy()

{

return s_UnhandledExceptionPolicy;

}

void Runtime::UnhandledException(Il2CppException* exc)

}

static inline Il2CppObject* InvokeConvertThis(const MethodInfo* method, void* thisArg, void** convertedParameters, Il2CppException** exception)

{

Il2CppClass* thisType = method->klass;

// If it's not a constructor, just invoke directly

if (strcmp(method->name, ".ctor") != 0 || method->klass == il2cpp_defaults.string_class)

{

void* obj = thisArg;

if (Class::IsNullable(method->klass))

{

Il2CppObject* nullable;

/* Convert the unboxed vtype into a Nullable structure */

nullable = Object::New(method->klass);

Il2CppObject* boxed = Object::Box(method->klass->castClass, obj);

Object::NullableInit((uint8_t*)Object::Unbox(nullable), boxed, method->klass);

obj = Object::Unbox(nullable);

}

return Runtime::Invoke(method, obj, convertedParameters, exception);

}

// If it is a construction, we need to construct a return value and allocate object if needed

Il2CppObject* instance;

if (thisArg == NULL)

{

if (Class::IsNullable(thisType))

{

// in the case of a Nullable constructor we can just return a boxed value type

IL2CPP_ASSERT(convertedParameters);

instance = Object::Box(thisType->castClass, convertedParameters[0]);

}

else

{

thisArg = instance = Object::New(thisType);

Runtime::Invoke(method, thisType->byval_arg.valuetype ? Object::Unbox((Il2CppObject*)thisArg) : thisArg, convertedParameters, exception);

}

}

else

{

// thisArg is pointer to data in case of a value type

// We need to invoke the constructor first, passing point to the value

// Since the constructor may modify the value, we need to box the result

// AFTER the constructor was invoked

Runtime::Invoke(method, thisArg, convertedParameters, exception);

instance = Object::Box(thisType, thisArg);

}

return instance;

}

Il2CppObject* Runtime::InvokeConvertArgs(const MethodInfo *method, void* thisArg, Il2CppObject** parameters, int paramCount, Il2CppException** exception)

{

void** convertedParameters = NULL;

bool hasByRefNullables = false;

// Convert parameters if they are not null

if (parameters != NULL)

{

convertedParameters = (void**)alloca(sizeof(void*) * paramCount);

for (int i = 0; i < paramCount; i++)

{

bool passedByReference = method->parameters[i]->byref;

Il2CppClass* parameterType = Class::FromIl2CppType(method->parameters[i]);

Class::Init(parameterType);

if (Class::IsValuetype(parameterType))

{

if (Class::IsNullable(parameterType))

{

// Since we don't really store boxed nullables, we need to create a new one.

void* nullableStorage = alloca(parameterType->instance_size - sizeof(Il2CppObject));

Object::UnboxNullable(parameters[i], parameterType, nullableStorage);

convertedParameters[i] = nullableStorage;

hasByRefNullables |= passedByReference;

}

else if (passedByReference)

{

// If value type is passed by reference, just pass pointer to value directly

// If null was passed in, create a new boxed value type in its place

if (parameters[i] == NULL)

gc::WriteBarrier::GenericStore(parameters + i, Object::New(parameterType));

convertedParameters[i] = Object::Unbox(parameters[i]);

}

else if (parameters[i] == NULL) // If value type is passed by value, we need to pass pointer to its value

{

// If null was passed in, allocate a new value with default value

uint32_t valueSize = parameterType->instance_size - sizeof(Il2CppObject);

convertedParameters[i] = alloca(valueSize);

memset(convertedParameters[i], 0, valueSize);

}

else

{

// Otherwise, pass the original

convertedParameters[i] = Object::Unbox(parameters[i]);

}

}

else if (passedByReference)

{

convertedParameters[i] = &parameters[i]; // Reference type passed by reference

}

else if (parameterType->byval_arg.type == IL2CPP_TYPE_PTR)

{

if (parameters[i] != NULL)

{

IL2CPP_ASSERT(parameters[i]->klass == il2cpp_defaults.int_class);

convertedParameters[i] = reinterpret_cast<void*>(*static_cast<intptr_t*>(Object::Unbox(parameters[i])));

}

else

{

convertedParameters[i] = NULL;

}

}

else

{

convertedParameters[i] = parameters[i]; // Reference type passed by value

}

}

}

Il2CppObject* result = InvokeConvertThis(method, thisArg, convertedParameters, exception);

if (hasByRefNullables)

{

// We need to copy by reference nullables back to original argument array

for (int i = 0; i < paramCount; i++)

{

if (!method->parameters[i]->byref)

continue;

Il2CppClass* parameterType = Class::FromIl2CppType(method->parameters[i]);

if (Class::IsNullable(parameterType))

gc::WriteBarrier::GenericStore(parameters + i, Object::Box(parameterType, convertedParameters[i]));

}

}

if (method->return_type->type == IL2CPP_TYPE_PTR)

{

static Il2CppClass* pointerClass = Class::FromName(il2cpp_defaults.corlib, "System.Reflection", "Pointer");

Il2CppReflectionPointer* pointer = reinterpret_cast<Il2CppReflectionPointer*>(Object::New(pointerClass));

pointer->data = result;

IL2CPP_OBJECT_SETREF(pointer, type, Reflection::GetTypeObject(method->return_type));

result = reinterpret_cast<Il2CppObject*>(pointer);

}

return result;

}

void Runtime::CallUnhandledExceptionDelegate(Il2CppDomain* domain, Il2CppDelegate* delegate, Il2CppException* exc)

}

static baselib::ReentrantLock s_TypeInitializationLock;

void Runtime::ClassInit(Il2CppClass *klass)

}

struct ConstCharCompare