#include "il2cpp-config.h"

#include "MetadataCache.h"

#include <map>

#include <limits>

#include "il2cpp-class-internals.h"

#include "il2cpp-tabledefs.h"

#include "il2cpp-runtime-stats.h"

#include "gc/GarbageCollector.h"

#include "metadata/ArrayMetadata.h"

#include "metadata/GenericMetadata.h"

#include "metadata/GenericMethod.h"

#include "metadata/Il2CppTypeCompare.h"

#include "metadata/Il2CppTypeHash.h"

#include "metadata/Il2CppTypeVector.h"

#include "metadata/Il2CppGenericContextCompare.h"

#include "metadata/Il2CppGenericContextHash.h"

#include "metadata/Il2CppGenericInstCompare.h"

#include "metadata/Il2CppGenericInstHash.h"

#include "metadata/Il2CppGenericMethodCompare.h"

#include "metadata/Il2CppGenericMethodHash.h"

#include "metadata/Il2CppSignatureCompare.h"

#include "metadata/Il2CppSignatureHash.h"

#include "os/Atomic.h"

#include "os/Mutex.h"

#include "utils/CallOnce.h"

#include "utils/Collections.h"

#include "utils/HashUtils.h"

#include "utils/Il2CppHashMap.h"

#include "utils/Il2CppHashSet.h"

#include "utils/Memory.h"

#include "utils/StringUtils.h"

#include "utils/PathUtils.h"

#include "vm/Assembly.h"

#include "vm/Class.h"

#include "vm/ClassInlines.h"

#include "vm/GenericClass.h"

#include "vm/MetadataAlloc.h"

#include "vm/MetadataLoader.h"

#include "vm/MetadataLock.h"

#include "vm/Method.h"

#include "vm/Object.h"

#include "vm/String.h"

#include "vm/Type.h"

#include "mono-runtime/il2cpp-mapping.h"

#include "vm-utils/NativeSymbol.h"

#include "vm-utils/VmStringUtils.h"

#include "hybridclr/metadata/Assembly.h"

#include "hybridclr/metadata/MetadataModule.h"

using namespace il2cpp::vm;

typedef std::map<Il2CppClass*, Il2CppClass*> PointerTypeMap;

typedef Il2CppHashMap<const char*, Il2CppClass*, il2cpp::utils::StringUtils::StringHasher<const char*>, il2cpp::utils::VmStringUtils::CaseSensitiveComparer> WindowsRuntimeTypeNameToClassMap;

typedef Il2CppHashMap<const Il2CppClass*, const char*, il2cpp::utils::PointerHash<Il2CppClass> > ClassToWindowsRuntimeTypeNameMap;

typedef Il2CppHashSet<const Il2CppGenericMethod*, il2cpp::metadata::Il2CppGenericMethodHash, il2cpp::metadata::Il2CppGenericMethodCompare> Il2CppGenericMethodSet;

typedef Il2CppGenericMethodSet::const_iterator Il2CppGenericMethodSetIter;

static Il2CppGenericMethodSet s_GenericMethodSet;

struct Il2CppMetadataCache

};

static Il2CppMetadataCache s_MetadataCache;

static Il2CppClass** s_TypeInfoTable = NULL;

static Il2CppClass** s_TypeInfoDefinitionTable = NULL;

static const MethodInfo** s_MethodInfoDefinitionTable = NULL;

static Il2CppString** s_StringLiteralTable = NULL;

static const Il2CppGenericMethod** s_GenericMethodTable = NULL;

static int32_t s_ImagesCount = 0;

static Il2CppImage* s_ImagesTable = NULL;

static int32_t s_AssembliesCount = 0;

static Il2CppAssembly* s_AssembliesTable = NULL;

typedef Il2CppHashSet<const Il2CppGenericInst*, il2cpp::metadata::Il2CppGenericInstHash, il2cpp::metadata::Il2CppGenericInstCompare> Il2CppGenericInstSet;

static Il2CppGenericInstSet s_GenericInstSet;

typedef Il2CppHashMap<const Il2CppGenericMethod*, const Il2CppGenericMethodIndices*, il2cpp::metadata::Il2CppGenericMethodHash, il2cpp::metadata::Il2CppGenericMethodCompare> Il2CppMethodTableMap;

typedef Il2CppMethodTableMap::const_iterator Il2CppMethodTableMapIter;

static Il2CppMethodTableMap s_MethodTableMap;

typedef Il2CppHashMap<il2cpp::utils::dynamic_array<const Il2CppType*>, Il2CppMethodPointer, il2cpp::metadata::Il2CppSignatureHash, il2cpp::metadata::Il2CppSignatureCompare> Il2CppUnresolvedSignatureMap;

typedef Il2CppUnresolvedSignatureMap::const_iterator Il2CppUnresolvedSignatureMapIter;

static Il2CppUnresolvedSignatureMap *s_pUnresolvedSignatureMap;

typedef Il2CppHashMap<FieldInfo*, int32_t, il2cpp::utils::PointerHash<FieldInfo> > Il2CppThreadLocalStaticOffsetHashMap;

typedef Il2CppThreadLocalStaticOffsetHashMap::iterator Il2CppThreadLocalStaticOffsetHashMapIter;

static Il2CppThreadLocalStaticOffsetHashMap s_ThreadLocalStaticOffsetMap;

static const Il2CppCodeRegistration * s_Il2CppCodeRegistration;

static const Il2CppMetadataRegistration * s_Il2CppMetadataRegistration;

static const Il2CppCodeGenOptions* s_Il2CppCodeGenOptions;

static CustomAttributesCache** s_CustomAttributesCaches;

static WindowsRuntimeTypeNameToClassMap s_WindowsRuntimeTypeNameToClassMap;

static ClassToWindowsRuntimeTypeNameMap s_ClassToWindowsRuntimeTypeNameMap;

struct InteropDataToTypeConverter

};

typedef il2cpp::utils::collections::ArrayValueMap<const Il2CppType*, Il2CppInteropData, InteropDataToTypeConverter, il2cpp::metadata::Il2CppTypeLess, il2cpp::metadata::Il2CppTypeEqualityComparer> InteropDataMap;

static InteropDataMap s_InteropData;

struct WindowsRuntimeFactoryTableEntryToTypeConverter

};

typedef il2cpp::utils::collections::ArrayValueMap<const Il2CppType*, Il2CppWindowsRuntimeFactoryTableEntry, WindowsRuntimeFactoryTableEntryToTypeConverter, il2cpp::metadata::Il2CppTypeLess, il2cpp::metadata::Il2CppTypeEqualityComparer> WindowsRuntimeFactoryTable;

static WindowsRuntimeFactoryTable s_WindowsRuntimeFactories;

template<typename K, typename V>

struct PairToKeyConverter

};

typedef il2cpp::utils::collections::ArrayValueMap<const Il2CppGuid*, std::pair<const Il2CppGuid*, Il2CppClass*>, PairToKeyConverter<const Il2CppGuid*, Il2CppClass*> > GuidToClassMap;

static GuidToClassMap s_GuidToNonImportClassMap;

static il2cpp::utils::dynamic_array<Il2CppAssembly*> s_cliAssemblies;

template<typename T>

static T MetadataOffset(void* metadata, size_t sectionOffset, size_t itemIndex)

{

return reinterpret_cast<T>(reinterpret_cast<uint8_t*>(metadata) + sectionOffset) + itemIndex;

}

void il2cpp::vm::MetadataCache::Register(const Il2CppCodeRegistration* const codeRegistration, const Il2CppMetadataRegistration* const metadataRegistration, const Il2CppCodeGenOptions* const codeGenOptions)

{

s_Il2CppCodeRegistration = codeRegistration;

s_Il2CppMetadataRegistration = metadataRegistration;

s_Il2CppCodeGenOptions = codeGenOptions;

s_InteropData.assign_external(codeRegistration->interopData, codeRegistration->interopDataCount);

s_WindowsRuntimeFactories.assign_external(codeRegistration->windowsRuntimeFactoryTable, codeRegistration->windowsRuntimeFactoryCount);

}

static void* s_GlobalMetadata;

static const Il2CppGlobalMetadataHeader* s_GlobalMetadataHeader;

typedef void (*Il2CppTypeUpdater)(Il2CppType*);

static void InitializeTypeHandle(Il2CppType* type)

{

type->data.typeHandle = il2cpp::vm::GlobalMetadata::GetTypeHandleFromIndex(type->data.__klassIndex);

}

static void ClearTypeHandle(Il2CppType* type)

{

type->data.__klassIndex = -1; // GetIndexForTypeDefinitionInternal(reinterpret_cast<const Il2CppTypeDefinition*>(type->data.typeHandle));

}

static void InitializeGenericParameterHandle(Il2CppType* type)

{

type->data.genericParameterHandle = il2cpp::vm::MetadataCache::GetGenericParameterFromIndex(type->data.__genericParameterIndex);

}

static void ClearGenericParameterHandle(Il2CppType* type)

{

type->data.__genericParameterIndex = -1;// GetIndexForGenericParameter(reinterpret_cast<Il2CppMetadataGenericParameterHandle>(type->data.genericParameterHandle));

}

static void ProcessIl2CppTypeDefinitions(Il2CppTypeUpdater updateTypeDef, Il2CppTypeUpdater updateGenericParam)

}

bool il2cpp::vm::MetadataCache::Initialize()

{

s_GlobalMetadata = vm::MetadataLoader::LoadMetadataFile("global-metadata.dat");

if (!s_GlobalMetadata)

return false;

il2cpp::metadata::GenericMetadata::SetMaximumRuntimeGenericDepth(s_Il2CppCodeGenOptions->maximumRuntimeGenericDepth);

s_GlobalMetadataHeader = (const Il2CppGlobalMetadataHeader*)s_GlobalMetadata;

IL2CPP_ASSERT(s_GlobalMetadataHeader->sanity == 0xFAB11BAF);

IL2CPP_ASSERT(s_GlobalMetadataHeader->version == 24);

// Pre-allocate these arrays so we don't need to lock when reading later.

// These arrays hold the runtime metadata representation for metadata explicitly

// referenced during conversion. There is a corresponding table of same size

// in the converted metadata, giving a description of runtime metadata to construct.

s_TypeInfoTable = (Il2CppClass**)IL2CPP_CALLOC(s_Il2CppMetadataRegistration->typesCount, sizeof(Il2CppClass*));

s_TypeInfoDefinitionTable = (Il2CppClass**)IL2CPP_CALLOC(s_GlobalMetadataHeader->typeDefinitionsCount / sizeof(Il2CppTypeDefinition), sizeof(Il2CppClass*));

s_MethodInfoDefinitionTable = (const MethodInfo**)IL2CPP_CALLOC(s_GlobalMetadataHeader->methodsCount / sizeof(Il2CppMethodDefinition), sizeof(MethodInfo*));

s_GenericMethodTable = (const Il2CppGenericMethod**)IL2CPP_CALLOC(s_Il2CppMetadataRegistration->methodSpecsCount, sizeof(Il2CppGenericMethod*));

s_ImagesCount = s_GlobalMetadataHeader->imagesCount / sizeof(Il2CppImageDefinition);

s_ImagesTable = (Il2CppImage*)IL2CPP_CALLOC(s_ImagesCount, sizeof(Il2CppImage));

s_AssembliesCount = s_GlobalMetadataHeader->assembliesCount / sizeof(Il2CppAssemblyDefinition);

s_AssembliesTable = (Il2CppAssembly*)IL2CPP_CALLOC(s_AssembliesCount, sizeof(Il2CppAssembly));

// setup all the Il2CppImages. There are not many and it avoid locks later on

const Il2CppImageDefinition* imagesDefinitions = (const Il2CppImageDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->imagesOffset);

for (int32_t imageIndex = 0; imageIndex < s_ImagesCount; imageIndex++)

{

const Il2CppImageDefinition* imageDefinition = imagesDefinitions + imageIndex;

Il2CppImage* image = s_ImagesTable + imageIndex;

image->name = GetStringFromIndex(imageDefinition->nameIndex);

std::string nameNoExt = il2cpp::utils::PathUtils::PathNoExtension(image->name);

image->nameNoExt = (char*)IL2CPP_CALLOC(nameNoExt.size() + 1, sizeof(char));

strcpy(const_cast<char*>(image->nameNoExt), nameNoExt.c_str());

image->assembly = const_cast<Il2CppAssembly*>(GetAssemblyFromIndex(image, imageDefinition->assemblyIndex));

image->typeStart = imageDefinition->typeStart;

image->typeCount = imageDefinition->typeCount;

image->exportedTypeStart = imageDefinition->exportedTypeStart;

image->exportedTypeCount = imageDefinition->exportedTypeCount;

image->entryPointIndex = imageDefinition->entryPointIndex;

image->token = imageDefinition->token;

image->customAttributeStart = imageDefinition->customAttributeStart;

image->customAttributeCount = imageDefinition->customAttributeCount;

for (uint32_t codeGenModuleIndex = 0; codeGenModuleIndex < s_Il2CppCodeRegistration->codeGenModulesCount; ++codeGenModuleIndex)

{

if (strcmp(image->name, s_Il2CppCodeRegistration->codeGenModules[codeGenModuleIndex]->moduleName) == 0)

image->codeGenModule = s_Il2CppCodeRegistration->codeGenModules[codeGenModuleIndex];

}

IL2CPP_ASSERT(image->codeGenModule);

image->dynamic = false;

}

// setup all the Il2CppAssemblies.

const Il2CppAssemblyDefinition* assemblyDefinitions = (const Il2CppAssemblyDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->assembliesOffset);

for (int32_t assemblyIndex = 0; assemblyIndex < s_ImagesCount; assemblyIndex++)

{

const Il2CppAssemblyDefinition* assemblyDefinition = assemblyDefinitions + assemblyIndex;

Il2CppAssembly* assembly = s_AssembliesTable + assemblyIndex;

assembly->image = il2cpp::vm::MetadataCache::GetImageFromIndex(assemblyDefinition->imageIndex);

assembly->token = assemblyDefinition->token;

assembly->referencedAssemblyStart = assemblyDefinition->referencedAssemblyStart;

assembly->referencedAssemblyCount = assemblyDefinition->referencedAssemblyCount;

Il2CppAssemblyName* assemblyName = &assembly->aname;

const Il2CppAssemblyNameDefinition* assemblyNameDefinition = &assemblyDefinition->aname;

assemblyName->name = GetStringFromIndex(assemblyNameDefinition->nameIndex);

assemblyName->culture = GetStringFromIndex(assemblyNameDefinition->cultureIndex);

assemblyName->public_key = (const uint8_t*)GetStringFromIndex(assemblyNameDefinition->publicKeyIndex);

assemblyName->hash_alg = assemblyNameDefinition->hash_alg;

assemblyName->hash_len = assemblyNameDefinition->hash_len;

assemblyName->flags = assemblyNameDefinition->flags;

assemblyName->major = assemblyNameDefinition->major;

assemblyName->minor = assemblyNameDefinition->minor;

assemblyName->build = assemblyNameDefinition->build;

assemblyName->revision = assemblyNameDefinition->revision;

memcpy(assemblyName->public_key_token, assemblyNameDefinition->public_key_token, sizeof(assemblyNameDefinition->public_key_token));

il2cpp::vm::Assembly::Register(assembly);

}

ProcessIl2CppTypeDefinitions(InitializeTypeHandle, InitializeGenericParameterHandle);

for (int32_t j = 0; j < s_Il2CppMetadataRegistration->genericClassesCount; j++)

{

Il2CppGenericClass* genericClass = s_Il2CppMetadataRegistration->genericClasses[j];

if (genericClass->__typeDefinitionIndex != kTypeIndexInvalid)

{

const Il2CppTypeDefinition* typeDefinition = GetTypeDefinitionFromIndex(genericClass->__typeDefinitionIndex);

genericClass->type = il2cpp::vm::MetadataCache::GetIl2CppTypeFromIndex(typeDefinition->byvalTypeIndex);

}

else

{

genericClass->type = nullptr;

}

}

for (int32_t j = 0; j < s_Il2CppMetadataRegistration->genericClassesCount; j++)

if (s_Il2CppMetadataRegistration->genericClasses[j]->type)

il2cpp::metadata::GenericMetadata::RegisterGenericClass(s_Il2CppMetadataRegistration->genericClasses[j]);

for (int32_t i = 0; i < s_Il2CppMetadataRegistration->genericInstsCount; i++)

s_GenericInstSet.insert(s_Il2CppMetadataRegistration->genericInsts[i]);

InitializeUnresolvedSignatureTable();

#if IL2CPP_ENABLE_NATIVE_STACKTRACES

std::vector<MethodDefinitionKey> managedMethods;

const Il2CppTypeDefinition* typeDefinitions = (const Il2CppTypeDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->typeDefinitionsOffset);

for (int32_t i = 0; i < s_AssembliesCount; i++)

{

const Il2CppImage* image = s_AssembliesTable[i].image;

for (size_t j = 0; j < image->typeCount; j++)

{

const Il2CppTypeDefinition* type = typeDefinitions + image->typeStart + j;

for (uint16_t u = 0; u < type->method_count; u++)

{

const Il2CppMethodDefinition* methodDefinition = GetMethodDefinitionFromIndex(type->methodStart + u);

MethodDefinitionKey currentMethodList;

currentMethodList.methodIndex = type->methodStart + u;

currentMethodList.method = GetMethodPointer(image, methodDefinition->token);

if (currentMethodList.method)

managedMethods.push_back(currentMethodList);

}

}

}

for (int32_t i = 0; i < s_Il2CppMetadataRegistration->genericMethodTableCount; i++)

{

const Il2CppGenericMethodFunctionsDefinitions* genericMethodIndices = s_Il2CppMetadataRegistration->genericMethodTable + i;

MethodDefinitionKey currentMethodList;

GenericMethodIndex genericMethodIndex = genericMethodIndices->genericMethodIndex;

IL2CPP_ASSERT(genericMethodIndex < s_Il2CppMetadataRegistration->methodSpecsCount);

const Il2CppMethodSpec* methodSpec = s_Il2CppMetadataRegistration->methodSpecs + genericMethodIndex;

currentMethodList.methodIndex = methodSpec->methodDefinitionIndex;

IL2CPP_ASSERT(genericMethodIndices->indices.methodIndex < static_cast<int32_t>(s_Il2CppCodeRegistration->genericMethodPointersCount));

currentMethodList.method = s_Il2CppCodeRegistration->genericMethodPointers[genericMethodIndices->indices.methodIndex];

managedMethods.push_back(currentMethodList);

}

il2cpp::utils::NativeSymbol::RegisterMethods(managedMethods);

#endif

return true;

}

void il2cpp::vm::MetadataCache::InitializeStringLiteralTable()

{

s_StringLiteralTable = (Il2CppString**)il2cpp::gc::GarbageCollector::AllocateFixed(s_GlobalMetadataHeader->stringLiteralCount / sizeof(Il2CppStringLiteral) * sizeof(Il2CppString*), NULL);

}

void il2cpp::vm::MetadataCache::InitializeGenericMethodTable()

{

for (int32_t i = 0; i < s_Il2CppMetadataRegistration->genericMethodTableCount; i++)

{

const Il2CppGenericMethodFunctionsDefinitions* genericMethodIndices = s_Il2CppMetadataRegistration->genericMethodTable + i;

const Il2CppGenericMethod* genericMethod = GetGenericMethodFromIndex(genericMethodIndices->genericMethodIndex);

s_MethodTableMap.insert(std::make_pair(genericMethod, &genericMethodIndices->indices));

}

}

void il2cpp::vm::MetadataCache::InitializeWindowsRuntimeTypeNamesTables()

{

int32_t typeCount = s_GlobalMetadataHeader->windowsRuntimeTypeNamesSize / sizeof(Il2CppWindowsRuntimeTypeNamePair);

const Il2CppWindowsRuntimeTypeNamePair* windowsRuntimeTypeNames = MetadataOffset<Il2CppWindowsRuntimeTypeNamePair*>(s_GlobalMetadata, s_GlobalMetadataHeader->windowsRuntimeTypeNamesOffset, 0);

for (int32_t i = 0; i < typeCount; i++)

{

Il2CppWindowsRuntimeTypeNamePair typeNamePair = windowsRuntimeTypeNames[i];

const char* name = GetStringFromIndex(typeNamePair.nameIndex);

const Il2CppType* type = GetIl2CppTypeFromIndex(typeNamePair.typeIndex);

Il2CppClass* klass = il2cpp::vm::Class::FromIl2CppType(type);

if (!Class::IsNullable(klass))

{

// Don't add nullable types to name -> klass map because IReference`1<T> and Nullable`1<T>

// share windows runtime type names, and that would cause a collision.

s_WindowsRuntimeTypeNameToClassMap.insert(std::make_pair(name, klass));

}

s_ClassToWindowsRuntimeTypeNameMap.insert(std::make_pair(klass, name));

}

}

void il2cpp::vm::MetadataCache::InitializeGuidToClassTable()

{

Il2CppInteropData* interopData = s_Il2CppCodeRegistration->interopData;

uint32_t interopDataCount = s_Il2CppCodeRegistration->interopDataCount;

std::vector<std::pair<const Il2CppGuid*, Il2CppClass*> > guidToNonImportClassMap;

guidToNonImportClassMap.reserve(interopDataCount);

for (uint32_t i = 0; i < interopDataCount; i++)

{

// It's important to check for non-import types because type projections will have identical GUIDs (e.g. IEnumerable<T> and IIterable<T>)

if (interopData[i].guid != NULL)

{

Il2CppClass* klass = Class::FromIl2CppType(interopData[i].type);

if (!klass->is_import_or_windows_runtime)

guidToNonImportClassMap.push_back(std::make_pair(interopData[i].guid, klass));

}

}

s_GuidToNonImportClassMap.assign(guidToNonImportClassMap);

}

void il2cpp::vm::MetadataCache::InitializeGCSafe()

{

InitializeStringLiteralTable();

InitializeGenericMethodTable();

InitializeWindowsRuntimeTypeNamesTables();

InitializeGuidToClassTable();

}

void il2cpp::vm::MetadataCache::InitializeUnresolvedSignatureTable()

{

s_pUnresolvedSignatureMap = new Il2CppUnresolvedSignatureMap();

for (uint32_t i = 0; i < s_Il2CppCodeRegistration->unresolvedVirtualCallCount; ++i)

{

const Il2CppRange* range = MetadataOffset<Il2CppRange*>(s_GlobalMetadata, s_GlobalMetadataHeader->unresolvedVirtualCallParameterRangesOffset, i);

il2cpp::utils::dynamic_array<const Il2CppType*> signature;

for (int j = 0; j < range->length; ++j)

{

TypeIndex typeIndex = *MetadataOffset<TypeIndex*>(s_GlobalMetadata, s_GlobalMetadataHeader->unresolvedVirtualCallParameterTypesOffset, range->start + j);

const Il2CppType* type = il2cpp::vm::MetadataCache::GetIl2CppTypeFromIndex(typeIndex);

signature.push_back(type);

}

(*s_pUnresolvedSignatureMap)[signature] = s_Il2CppCodeRegistration->unresolvedVirtualCallPointers[i];

}

}

Il2CppClass* il2cpp::vm::MetadataCache::GetGenericInstanceType(Il2CppClass* genericTypeDefinition, const il2cpp::metadata::Il2CppTypeVector& genericArgumentTypes)

{

const Il2CppGenericInst* inst = il2cpp::vm::MetadataCache::GetGenericInst(genericArgumentTypes);

Il2CppGenericClass* genericClass = il2cpp::metadata::GenericMetadata::GetGenericClass(genericTypeDefinition, inst);

return il2cpp::vm::GenericClass::GetClass(genericClass);

}

const MethodInfo* il2cpp::vm::MetadataCache::GetGenericInstanceMethod(const MethodInfo* genericMethodDefinition, const Il2CppGenericContext* context)

{

const MethodInfo* method = genericMethodDefinition;

const Il2CppGenericInst* classInst = context->class_inst;

const Il2CppGenericInst* methodInst = context->method_inst;

if (genericMethodDefinition->is_inflated)

{

IL2CPP_ASSERT(genericMethodDefinition->klass->generic_class);

classInst = genericMethodDefinition->klass->generic_class->context.class_inst;

method = genericMethodDefinition->genericMethod->methodDefinition;

}

const Il2CppGenericMethod* gmethod = GetGenericMethod(method, classInst, methodInst);

return il2cpp::metadata::GenericMethod::GetMethod(gmethod);

}

const MethodInfo* il2cpp::vm::MetadataCache::GetGenericInstanceMethod(const MethodInfo* genericMethodDefinition, const il2cpp::metadata::Il2CppTypeVector& genericArgumentTypes)

{

Il2CppGenericContext context = { NULL, GetGenericInst(genericArgumentTypes) };

return GetGenericInstanceMethod(genericMethodDefinition, &context);

}

const Il2CppGenericContext* il2cpp::vm::MetadataCache::GetMethodGenericContext(const MethodInfo* method)

{

if (!method->is_inflated)

{

IL2CPP_NOT_IMPLEMENTED(Image::GetMethodGenericContext);

return NULL;

}

return &method->genericMethod->context;

}

const MethodInfo* il2cpp::vm::MetadataCache::GetGenericMethodDefinition(const MethodInfo* method)

{

if (!method->is_inflated)

{

IL2CPP_NOT_IMPLEMENTED(Image::GetGenericMethodDefinition);

return NULL;

}

return method->genericMethod->methodDefinition;

}

const Il2CppGenericContainer* il2cpp::vm::MetadataCache::GetMethodGenericContainer(const MethodInfo* method)

{

return method->genericContainer;

}

Il2CppClass* il2cpp::vm::MetadataCache::GetPointerType(Il2CppClass* type)

{

il2cpp::os::FastAutoLock lock(&s_MetadataCache.m_CacheMutex);

PointerTypeMap::const_iterator i = s_MetadataCache.m_PointerTypes.find(type);

if (i == s_MetadataCache.m_PointerTypes.end())

return NULL;

return i->second;

}

Il2CppClass* il2cpp::vm::MetadataCache::GetWindowsRuntimeClass(const char* fullName)

{

WindowsRuntimeTypeNameToClassMap::iterator it = s_WindowsRuntimeTypeNameToClassMap.find(fullName);

if (it != s_WindowsRuntimeTypeNameToClassMap.end())

return it->second;

return NULL;

}

const char* il2cpp::vm::MetadataCache::GetWindowsRuntimeClassName(const Il2CppClass* klass)

{

ClassToWindowsRuntimeTypeNameMap::iterator it = s_ClassToWindowsRuntimeTypeNameMap.find(klass);

if (it != s_ClassToWindowsRuntimeTypeNameMap.end())

return it->second;

return NULL;

}

Il2CppMethodPointer il2cpp::vm::MetadataCache::GetWindowsRuntimeFactoryCreationFunction(const char* fullName)

{

Il2CppClass* klass = GetWindowsRuntimeClass(fullName);

if (klass == NULL)

return NULL;

WindowsRuntimeFactoryTable::iterator factoryEntry = s_WindowsRuntimeFactories.find_first(&klass->byval_arg);

if (factoryEntry == s_WindowsRuntimeFactories.end())

return NULL;

return factoryEntry->createFactoryFunction;

}

Il2CppClass* il2cpp::vm::MetadataCache::GetClassForGuid(const Il2CppGuid* guid)

{

IL2CPP_ASSERT(guid != NULL);

GuidToClassMap::iterator it = s_GuidToNonImportClassMap.find_first(guid);

if (it != s_GuidToNonImportClassMap.end())

return it->second;

return NULL;

}

void il2cpp::vm::MetadataCache::AddPointerType(Il2CppClass* type, Il2CppClass* pointerType)

{

il2cpp::os::FastAutoLock lock(&s_MetadataCache.m_CacheMutex);

s_MetadataCache.m_PointerTypes.insert(std::make_pair(type, pointerType));

}

const Il2CppGenericInst* il2cpp::vm::MetadataCache::GetGenericInst(const Il2CppType* const* types, uint32_t typeCount)

{

// temporary inst to lookup a permanent one that may already exist

Il2CppGenericInst inst;

inst.type_argc = typeCount;

inst.type_argv = (const Il2CppType**)alloca(inst.type_argc * sizeof(Il2CppType*));

size_t index = 0;

const Il2CppType* const* typesEnd = types + typeCount;

for (const Il2CppType* const* iter = types; iter != typesEnd; ++iter, ++index)

inst.type_argv[index] = *iter;

{

// Acquire lock to check if inst has already been cached.

il2cpp::os::FastAutoLock lock(&s_MetadataCache.m_CacheMutex);

Il2CppGenericInstSet::const_iterator iter = s_GenericInstSet.find(&inst);

if (iter != s_GenericInstSet.end())

return *iter;

}

Il2CppGenericInst* newInst = NULL;

{

il2cpp::os::FastAutoLock lock(&g_MetadataLock);

newInst = (Il2CppGenericInst*)MetadataMalloc(sizeof(Il2CppGenericInst));

newInst->type_argc = typeCount;

newInst->type_argv = (const Il2CppType**)MetadataMalloc(newInst->type_argc * sizeof(Il2CppType*));

}

index = 0;

for (const Il2CppType* const* iter = types; iter != typesEnd; ++iter, ++index)

newInst->type_argv[index] = *iter;

{

// Acquire lock agains to attempt to cache inst.

il2cpp::os::FastAutoLock lock(&s_MetadataCache.m_CacheMutex);

// Another thread may have already added this inst or we may be the first.

// In either case, the iterator returned from 'insert' points to the item

// cached within the set. We can always return this. In the case of another

// thread beating us, the only downside is an extra allocation in the

// metadata memory pool that lives for life of process anyway.

auto result = s_GenericInstSet.insert(newInst);

if (result.second)

++il2cpp_runtime_stats.generic_instance_count;

return *(result.first);

}

}

const Il2CppGenericInst* il2cpp::vm::MetadataCache::GetGenericInst(const il2cpp::metadata::Il2CppTypeVector& types)

{

return GetGenericInst(&types[0], static_cast<uint32_t>(types.size()));

}

static il2cpp::os::FastMutex s_GenericMethodMutex;

const Il2CppGenericMethod* il2cpp::vm::MetadataCache::GetGenericMethod(const MethodInfo* methodDefinition, const Il2CppGenericInst* classInst, const Il2CppGenericInst* methodInst)

{

Il2CppGenericMethod method = { 0 };

method.methodDefinition = methodDefinition;

method.context.class_inst = classInst;

method.context.method_inst = methodInst;

il2cpp::os::FastAutoLock lock(&s_GenericMethodMutex);

Il2CppGenericMethodSet::const_iterator iter = s_GenericMethodSet.find(&method);

if (iter != s_GenericMethodSet.end())

return *iter;

Il2CppGenericMethod* newMethod = MetadataAllocGenericMethod();

newMethod->methodDefinition = methodDefinition;

newMethod->context.class_inst = classInst;

newMethod->context.method_inst = methodInst;

s_GenericMethodSet.insert(newMethod);

return newMethod;

}

static bool IsShareableEnum(const Il2CppType* type)

}

static const Il2CppGenericInst* GetSharedInst(const Il2CppGenericInst* inst)

{

if (inst == NULL)

return NULL;

il2cpp::metadata::Il2CppTypeVector types;

for (uint32_t i = 0; i < inst->type_argc; ++i)

{

if (il2cpp::vm::Type::IsReference(inst->type_argv[i]))

types.push_back(&il2cpp_defaults.object_class->byval_arg);

else

{

const Il2CppType* type = inst->type_argv[i];

if (s_Il2CppCodeGenOptions->enablePrimitiveValueTypeGenericSharing)

{

if (IsShareableEnum(type))

{

const Il2CppType* underlyingType = il2cpp::vm::Type::GetUnderlyingType(type);

switch (underlyingType->type)

{

case IL2CPP_TYPE_I1:

type = &il2cpp_defaults.sbyte_shared_enum->byval_arg;

break;

case IL2CPP_TYPE_I2:

type = &il2cpp_defaults.int16_shared_enum->byval_arg;

break;

case IL2CPP_TYPE_I4:

type = &il2cpp_defaults.int32_shared_enum->byval_arg;

break;

case IL2CPP_TYPE_I8:

type = &il2cpp_defaults.int64_shared_enum->byval_arg;

break;

case IL2CPP_TYPE_U1:

type = &il2cpp_defaults.byte_shared_enum->byval_arg;

break;

case IL2CPP_TYPE_U2:

type = &il2cpp_defaults.uint16_shared_enum->byval_arg;

break;

case IL2CPP_TYPE_U4:

type = &il2cpp_defaults.uint32_shared_enum->byval_arg;

break;

case IL2CPP_TYPE_U8:

type = &il2cpp_defaults.uint64_shared_enum->byval_arg;

break;

default:

IL2CPP_ASSERT(0 && "Invalid enum underlying type");

break;

}

}

}

if (il2cpp::vm::Type::IsGenericInstance(type))

{

const Il2CppGenericInst* sharedInst = GetSharedInst(type->data.generic_class->context.class_inst);

Il2CppGenericClass* gklass = il2cpp::metadata::GenericMetadata::GetGenericClass(type->data.generic_class->type, sharedInst);

Il2CppClass* klass = il2cpp::vm::GenericClass::GetClass(gklass);

type = &klass->byval_arg;

}

types.push_back(type);

}

}

const Il2CppGenericInst* sharedInst = il2cpp::vm::MetadataCache::GetGenericInst(types);

return sharedInst;

}

InvokerMethod il2cpp::vm::MetadataCache::GetInvokerMethodPointer(const MethodInfo* methodDefinition, const Il2CppGenericContext* context)

{

Il2CppGenericMethod method = { 0 };

method.methodDefinition = const_cast<MethodInfo*>(methodDefinition);

method.context.class_inst = context->class_inst;

method.context.method_inst = context->method_inst;

Il2CppMethodTableMapIter iter = s_MethodTableMap.find(&method);

if (iter != s_MethodTableMap.end())

{

IL2CPP_ASSERT(iter->second->invokerIndex >= 0);

if (static_cast<uint32_t>(iter->second->invokerIndex) < s_Il2CppCodeRegistration->invokerPointersCount)

return s_Il2CppCodeRegistration->invokerPointers[iter->second->invokerIndex];

return NULL;

}

// get the shared version if it exists

method.context.class_inst = GetSharedInst(context->class_inst);

method.context.method_inst = GetSharedInst(context->method_inst);

iter = s_MethodTableMap.find(&method);

if (iter != s_MethodTableMap.end())

{

IL2CPP_ASSERT(iter->second->invokerIndex >= 0);

if (static_cast<uint32_t>(iter->second->invokerIndex) < s_Il2CppCodeRegistration->invokerPointersCount)

return s_Il2CppCodeRegistration->invokerPointers[iter->second->invokerIndex];

return NULL;

}

return NULL;

}

Il2CppMethodPointer il2cpp::vm::MetadataCache::GetMethodPointer(const MethodInfo* methodDefinition, const Il2CppGenericContext* context, bool adjustorThunk, bool methodPointer)

{

Il2CppGenericMethod method = { 0 };

method.methodDefinition = const_cast<MethodInfo*>(methodDefinition);

method.context.class_inst = context->class_inst;

method.context.method_inst = context->method_inst;

Il2CppMethodTableMapIter iter = s_MethodTableMap.find(&method);

if (iter != s_MethodTableMap.end())

{

IL2CPP_ASSERT(iter->second->invokerIndex >= 0);

if (iter->second->adjustorThunkIndex != -1 && adjustorThunk)

return s_Il2CppCodeRegistration->genericAdjustorThunks[iter->second->adjustorThunkIndex];

if (static_cast<uint32_t>(iter->second->methodIndex) < s_Il2CppCodeRegistration->genericMethodPointersCount && methodPointer)

return s_Il2CppCodeRegistration->genericMethodPointers[iter->second->methodIndex];

return NULL;

}

method.context.class_inst = GetSharedInst(context->class_inst);

method.context.method_inst = GetSharedInst(context->method_inst);

iter = s_MethodTableMap.find(&method);

if (iter != s_MethodTableMap.end())

{

IL2CPP_ASSERT(iter->second->invokerIndex >= 0);

if (iter->second->adjustorThunkIndex != -1 && adjustorThunk)

return s_Il2CppCodeRegistration->genericAdjustorThunks[iter->second->adjustorThunkIndex];

if (static_cast<uint32_t>(iter->second->methodIndex) < s_Il2CppCodeRegistration->genericMethodPointersCount && methodPointer)

return s_Il2CppCodeRegistration->genericMethodPointers[iter->second->methodIndex];

return NULL;

}

return NULL;

}

Il2CppClass* il2cpp::vm::MetadataCache::GetTypeInfoFromTypeIndex(TypeIndex index, bool throwOnError)

{

if (index == kTypeIndexInvalid)

return NULL;

if (hybridclr::metadata::IsInterpreterIndex(index))

{

Il2CppClass* klass = il2cpp::vm::Class::FromIl2CppType(hybridclr::metadata::MetadataModule::GetIl2CppTypeFromEncodeIndex(index));

ClassInlines::InitFromCodegen(klass);

return klass;

}

IL2CPP_ASSERT(index < s_Il2CppMetadataRegistration->typesCount && "Invalid type index ");

if (s_TypeInfoTable[index])

return s_TypeInfoTable[index];

const Il2CppType* type = s_Il2CppMetadataRegistration->types[index];

Il2CppClass *klass = il2cpp::vm::Class::FromIl2CppType(type, throwOnError);

if (klass)

{

il2cpp::vm::ClassInlines::InitFromCodegen(klass);

s_TypeInfoTable[index] = klass;

}

return s_TypeInfoTable[index];

}

const Il2CppType* il2cpp::vm::MetadataCache::GetIl2CppTypeFromIndex(TypeIndex index)

{

if (index == kTypeIndexInvalid)

return NULL;

if (hybridclr::metadata::IsInterpreterIndex(index))

{

return hybridclr::metadata::MetadataModule::GetIl2CppTypeFromEncodeIndex(index);

}

IL2CPP_ASSERT(index < s_Il2CppMetadataRegistration->typesCount && "Invalid type index ");

return s_Il2CppMetadataRegistration->types[index];

}

const MethodInfo* il2cpp::vm::MetadataCache::GetMethodInfoFromIndex(EncodedMethodIndex methodIndex)

{

uint32_t index = GetDecodedMethodIndex(methodIndex);

if (index == 0)

return NULL;

if (GetEncodedIndexType(methodIndex) == kIl2CppMetadataUsageMethodRef)

return il2cpp::metadata::GenericMethod::GetMethod(GetGenericMethodFromIndex(index));

else

return il2cpp::vm::MetadataCache::GetMethodInfoFromMethodDefinitionIndex(index);

}

const Il2CppGenericMethod* il2cpp::vm::MetadataCache::GetGenericMethodFromIndex(GenericMethodIndex index)

{

IL2CPP_ASSERT(index < s_Il2CppMetadataRegistration->methodSpecsCount);

if (s_GenericMethodTable[index])

return s_GenericMethodTable[index];

const Il2CppMethodSpec* methodSpec = s_Il2CppMetadataRegistration->methodSpecs + index;

const MethodInfo* methodDefinition = GetMethodInfoFromMethodDefinitionIndex(methodSpec->methodDefinitionIndex);

const Il2CppGenericInst* classInst = NULL;

const Il2CppGenericInst* methodInst = NULL;

if (methodSpec->classIndexIndex != -1)

{

IL2CPP_ASSERT(methodSpec->classIndexIndex < s_Il2CppMetadataRegistration->genericInstsCount);

classInst = s_Il2CppMetadataRegistration->genericInsts[methodSpec->classIndexIndex];

}

if (methodSpec->methodIndexIndex != -1)

{

IL2CPP_ASSERT(methodSpec->methodIndexIndex < s_Il2CppMetadataRegistration->genericInstsCount);

methodInst = s_Il2CppMetadataRegistration->genericInsts[methodSpec->methodIndexIndex];

}

s_GenericMethodTable[index] = GetGenericMethod(methodDefinition, classInst, methodInst);

return s_GenericMethodTable[index];

}

static int CompareIl2CppTokenAdjustorThunkPair(const void* pkey, const void* pelem)

{

return (int)(((Il2CppTokenAdjustorThunkPair*)pkey)->token - ((Il2CppTokenAdjustorThunkPair*)pelem)->token);

}

Il2CppMethodPointer il2cpp::vm::MetadataCache::GetAdjustorThunk(const Il2CppImage* image, uint32_t token)

{

if (hybridclr::metadata::IsInterpreterIndex(image->token))

{

return hybridclr::metadata::MetadataModule::GetAdjustorThunk(image, token);

}

if (image->codeGenModule->adjustorThunkCount == 0)

return NULL;

Il2CppTokenAdjustorThunkPair key;

memset(&key, 0, sizeof(Il2CppTokenAdjustorThunkPair));

key.token = token;

const Il2CppTokenAdjustorThunkPair* result = (const Il2CppTokenAdjustorThunkPair*)bsearch(&key, image->codeGenModule->adjustorThunks,

image->codeGenModule->adjustorThunkCount, sizeof(Il2CppTokenAdjustorThunkPair), CompareIl2CppTokenAdjustorThunkPair);

if (result == NULL)

return NULL;

return result->adjustorThunk;

}

Il2CppMethodPointer il2cpp::vm::MetadataCache::GetMethodPointer(const Il2CppImage* image, uint32_t token)

{

uint32_t rid = GetTokenRowId(token);

uint32_t table = GetTokenType(token);

if (rid == 0)

return NULL;

if (hybridclr::metadata::IsInterpreterImage(image))

{

return hybridclr::metadata::MetadataModule::GetMethodPointer(image, token);

}

IL2CPP_ASSERT(rid <= image->codeGenModule->methodPointerCount);

return image->codeGenModule->methodPointers[rid - 1];

}

InvokerMethod il2cpp::vm::MetadataCache::GetMethodInvoker(const Il2CppImage* image, uint32_t token)

{

uint32_t rid = GetTokenRowId(token);

uint32_t table = GetTokenType(token);

if (rid == 0)

return NULL;

if (hybridclr::metadata::IsInterpreterImage(image))

{

return hybridclr::metadata::MetadataModule::GetMethodInvoker(image, token);

}

int32_t index = image->codeGenModule->invokerIndices[rid - 1];

if (index == kMethodIndexInvalid)

return NULL;

IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) < s_Il2CppCodeRegistration->invokerPointersCount);

return s_Il2CppCodeRegistration->invokerPointers[index];

}

const Il2CppInteropData* il2cpp::vm::MetadataCache::GetInteropDataForType(const Il2CppType* type)

{

IL2CPP_ASSERT(type != NULL);

InteropDataMap::iterator interopData = s_InteropData.find_first(type);

if (interopData == s_InteropData.end())

return NULL;

return interopData;

}

static bool MatchTokens(Il2CppTokenIndexMethodTuple key, Il2CppTokenIndexMethodTuple element)

{

return key.token < element.token;

}

Il2CppMethodPointer il2cpp::vm::MetadataCache::GetReversePInvokeWrapper(const Il2CppImage* image, const MethodInfo* method)

{

if (hybridclr::metadata::IsInterpreterImage(image))

{

return hybridclr::metadata::MetadataModule::GetReversePInvokeWrapper(image, method);

}

if (image->codeGenModule->reversePInvokeWrapperCount == 0)

return NULL;

// For each image (i.e. assembly), the reverse pinvoke wrapper indices are in an array sorted by

// metadata token. Each entry also might have the method metadata pointer, which is used to further

// find methods that have a matching metadata token.

Il2CppTokenIndexMethodTuple key;

memset(&key, 0, sizeof(Il2CppTokenIndexMethodTuple));

key.token = method->token;

// Binary search for a range which matches the metadata token.

auto begin = image->codeGenModule->reversePInvokeWrapperIndices;

auto end = image->codeGenModule->reversePInvokeWrapperIndices + image->codeGenModule->reversePInvokeWrapperCount;

auto matchingRange = std::equal_range(begin, end, key, &MatchTokens);

int32_t index = -1;

auto numberOfMatches = std::distance(matchingRange.first, matchingRange.second);

if (numberOfMatches == 1)

{

// Normal case - we found one non-generic method.