public static tAsyncCall *set_Target(tJITCallNative *pCallNative, byte *pThis_, byte *pParams, byte *pReturnValue) { tWeakRef * pThis = (tWeakRef *)pThis_; /*HEAP_PTR*/ byte *target = ((/*HEAP_PTR*/ byte **)pParams)[0]; if (pThis->target != null) { tWeakRef **ppWeakRef = (tWeakRef **)Heap.GetWeakRefAddress(pThis->target); while (*ppWeakRef != null) { tWeakRef *pWeakRef = *ppWeakRef; if (pWeakRef == pThis) { *ppWeakRef = pWeakRef->pNextWeakRef; Heap.RemovedWeakRefTarget(pWeakRef->target); goto foundOK; } ppWeakRef = &(pWeakRef->pNextWeakRef); } Sys.Crash("WeakRef.set_Target() Error: cannot find weak-ref target for removal"); foundOK :; } pThis->target = target; if (target != null) { pThis->pNextWeakRef = (tWeakRef *)Heap.SetWeakRefTarget(target, (/*HEAP_PTR*/ byte *)pThis); } return(null); }
public static void GetConstant(tMetaData *pThis, /*IDX_TABLE*/ uint idx, byte *pResultMem) { tMD_Constant *pConst = null; switch (MetaData.TABLE_ID(idx)) { case MetaDataTable.MD_TABLE_FIELDDEF: { tMD_FieldDef *pField = (tMD_FieldDef *)MetaData.GetTableRow(pThis, idx); pConst = (tMD_Constant *)pField->pMemory; } break; default: Sys.Crash("MetaData.GetConstant() Cannot handle idx: 0x%08x", idx); break; } switch (pConst->type) { case Type.ELEMENT_TYPE_I4: //*(uint*)pReturnMem = MetaData.DecodeSigEntry( Mem.memcpy(pResultMem, pConst->value + 1, 4); return; default: Sys.Crash("MetaData.GetConstant() Cannot handle value type: 0x%02x", pConst->type); break; } }
public static tMetaData *GetResolutionScopeMetaData(tMetaData *pMetaData, /*IDX_TABLE*/ uint resolutionScopeToken, tMD_TypeDef **ppInNestedType) { switch (MetaData.TABLE_ID(resolutionScopeToken)) { case MetaDataTable.MD_TABLE_ASSEMBLYREF: { tMD_AssemblyRef *pAssemblyRef; pAssemblyRef = (tMD_AssemblyRef *)MetaData.GetTableRow(pMetaData, resolutionScopeToken); *ppInNestedType = null; return(CLIFile.GetMetaDataForAssembly(pAssemblyRef->name)); } case MetaDataTable.MD_TABLE_TYPEREF: { tMD_TypeDef *pTypeDef; pTypeDef = MetaData.GetTypeDefFromDefRefOrSpec(pMetaData, resolutionScopeToken, null, null); *ppInNestedType = pTypeDef; return(pTypeDef->pMetaData); } default: Sys.Crash("MetaData.GetResolutionScopeMetaData(): Cannot resolve token: 0x%08x", resolutionScopeToken); return(null); } }
public static tMD_FieldDef *GetFieldDefFromDefOrRef(tMetaData *pMetaData, /*IDX_TABLE*/ uint token, tMD_TypeDef **ppClassTypeArgs, tMD_TypeDef **ppMethodTypeArgs) { void *pTableEntry; pTableEntry = MetaData.GetTableRow(pMetaData, token); if (((tMDC_ToFieldDef *)pTableEntry)->pFieldDef != null) { return(((tMDC_ToFieldDef *)pTableEntry)->pFieldDef); } switch (MetaData.TABLE_ID(token)) { case MetaDataTable.MD_TABLE_FIELDDEF: ((tMDC_ToFieldDef *)pTableEntry)->pFieldDef = (tMD_FieldDef *)pTableEntry; return((tMD_FieldDef *)pTableEntry); case MetaDataTable.MD_TABLE_MEMBERREF: { tMD_MemberRef *pMemberRef; pMemberRef = (tMD_MemberRef *)pTableEntry; switch (MetaData.TABLE_ID(pMemberRef->class_)) { case MetaDataTable.MD_TABLE_TYPEREF: case MetaDataTable.MD_TABLE_TYPESPEC: { tMD_TypeDef * pTypeDef; tMD_FieldDef *pFieldDef; pTypeDef = MetaData.GetTypeDefFromDefRefOrSpec(pMetaData, pMemberRef->class_, ppClassTypeArgs, ppMethodTypeArgs); pFieldDef = FindFieldInType(pTypeDef, pMemberRef->name); if (MetaData.TABLE_ID(pMemberRef->class_) == MetaDataTable.MD_TABLE_TYPEREF) { // Can't do this for TypeSpec because the resulting TypeDef will change // depending on what the class type arguments are. ((tMDC_ToFieldDef *)pTableEntry)->pFieldDef = pFieldDef; } return(pFieldDef); } default: Sys.Crash("MetaData.GetMethodDefFromMethodDefOrRef(): Cannot handle pMemberRef->class_=0x%08x", pMemberRef->class_); break; } return(null); } } Sys.Crash("MetaData.GetFieldDefFromDefOrRef(): Cannot handle token: 0x%08x", token); return(null); }
static byte[] BuildTableRowSize(params int[] args) { byte[] rowSize = new byte[args.Length]; for (int tableID = 0; tableID < args.Length; tableID++) { byte *pDef = tableDefs[tableID]; if (pDef != null) { int defLen = (int)S.strlen(pDef); int rowLen = 0; for (int i = 0; i < defLen; i += 2) { switch ((char)pDef[i + 1]) { case '*': rowLen += sizeof(SIZE_T); break; case 'i': rowLen += 4; break; case 's': rowLen += 2; break; case 'c': rowLen++; break; case 'x': // Do nothing break; default: Sys.Crash("Cannot determine length of MetaData destination definition character '%c'\n", pDef[tableID + 1]); break; } } int structLen = args[tableID]; if (rowLen != structLen) { Sys.Crash("Metadata decoder string row len does not match target struct size %d != %d", rowLen, structLen); } } rowSize[tableID] = (byte)args[tableID]; } return(rowSize); }
public static tCLIFile *WrapMonoAssembly(/*char**/ byte *pAssemblyName) { tCLIFile * pRet; tFilesLoaded *pNewFile; tMetaData * pMetaData; System.Reflection.Assembly assembly = null; string assemblyName = Marshal.PtrToStringAnsi((System.IntPtr)pAssemblyName); System.Reflection.Assembly[] assemblies = System.AppDomain.CurrentDomain.GetAssemblies(); for (int i = 0; i < assemblies.Length; i++) { System.Reflection.Assembly assem = assemblies[i]; if (assem.GetName().Name == assemblyName) { assembly = assem; break; } } if (assembly == null) { Sys.Crash("Unable to load assembly file %s", (PTR)pAssemblyName); } pRet = ((tCLIFile *)Mem.malloc((SIZE_T)sizeof(tCLIFile))); Mem.memset(pRet, 0, (SIZE_T)sizeof(tCLIFile)); pRet->pMetaData = pMetaData = MetaData.New(); MetaData.WrapMonoAssembly(pMetaData, assembly); string codeBase = assembly.CodeBase; System.UriBuilder uri = new System.UriBuilder(codeBase); string path = System.Uri.UnescapeDataString(uri.Path); string assmName = System.IO.Path.GetFileNameWithoutExtension(path); pRet->assemblyName = new S(assmName); // Record that we've loaded this file pNewFile = ((tFilesLoaded *)Mem.mallocForever((SIZE_T)sizeof(tFilesLoaded))); pNewFile->pCLIFile = pRet; pNewFile->pNext = pFilesLoaded; pFilesLoaded = pNewFile; return(pRet); }
public static tMD_ImplMap *GetImplMap(tMetaData *pMetaData, /*IDX_TABLE*/ uint memberForwardedToken) { uint i; for (i = pMetaData->tables.numRows[MetaDataTable.MD_TABLE_IMPLMAP]; i >= 1; i--) { tMD_ImplMap *pImplMap = (tMD_ImplMap *)MetaData.GetTableRow(pMetaData, MetaData.MAKE_TABLE_INDEX(MetaDataTable.MD_TABLE_IMPLMAP, i)); if (pImplMap->memberForwarded == memberForwardedToken) { return(pImplMap); } } Sys.Crash("MetaData.GetImplMap() Cannot find mapping for token: 0x%08x", memberForwardedToken); return(null); }
public static /*fnInternalCall*/ void *Map(tMD_MethodDef *pMethod) { if (pMethod->monoMethodCall != null) { return(pMethod->monoMethodCall); } else if (pMethod->pParentType->pParent == Type.types[Type.TYPE_SYSTEM_MULTICASTDELEGATE]) { // Special case to handle delegates /*fnInternalCall*/ void *fn = Map_Delegate(pMethod); if (fn != null) { return(fn); } } else { /*STRING*/ byte *curNameSpace = null; /*STRING*/ byte *curType = null; for (int i = 0; i < internalCalls.Length; i++) { fixed(tInternalCall *pCall = &internalCalls[i]) { if (pCall->nameSpace != null) { curNameSpace = pCall->nameSpace; } if (pCall->type != null) { curType = pCall->type; } if (S.strcmp(pMethod->pParentType->nameSpace, curNameSpace) == 0) { if (S.strcmp(pMethod->pParentType->name, curType) == 0) { if (Type.IsMethod(pMethod, pCall->method, Type.types[pCall->returnType], pCall->numParameters, pCall->parameterTypes) != 0) { return(pCall->fn); } } } } } } Sys.Crash("InternalCall_Map(): Cannot map [%s]%s.%s", (PTR)pMethod->pParentType->nameSpace, (PTR)pMethod->pParentType->name, (PTR)pMethod->name); return(null); }
public static tMD_TypeDef *GetType(/*HEAP_PTR*/ byte *heapObj) { #if DEBUG_HEAP if (heapObj == null) { Sys.Crash("Null reference to heap obj"); } #endif tHeapEntry *pHeapEntry = GET_HEAPENTRY(heapObj); #if DEBUG_HEAP if (pHeapEntry->signature != VALID_HEAP_OBJ_SIG) { Sys.Crash("Invalid heap object in GetMonoObject()"); } #endif return(pHeapEntry->pTypeDef); }
static tMD_FieldDef *FindFieldInType(tMD_TypeDef *pTypeDef, /*STRING*/ byte *name) { uint i; MetaData.Fill_TypeDef(pTypeDef, null, null, Type.TYPE_FILL_LAYOUT); for (i = 0; i < pTypeDef->numFields; i++) { if (S.strcmp(pTypeDef->ppFields[i]->name, name) == 0) { return(pTypeDef->ppFields[i]); } } Sys.Crash("FindFieldInType(): Cannot find field '%s' in type %s.%s", (PTR)name, (PTR)pTypeDef->nameSpace, (PTR)pTypeDef->name); return(null); }
public static /*HEAP_PTR*/ byte *Alloc(tMD_TypeDef *pTypeDef, uint size) { tHeapEntry *pHeapEntry; uint totalSize; byte * pMem; if (pTypeDef == null) { Sys.Crash("Invalid heap type!"); } totalSize = (uint)sizeof(tHeapEntry) + size; // Trigger garbage collection if required. if (trackHeapSize >= heapSizeMax) { GarbageCollect(); heapSizeMax = (trackHeapSize + totalSize) << 1; if (heapSizeMax < trackHeapSize + totalSize + MIN_HEAP_SIZE) { // Make sure there is always MIN_HEAP_SIZE available to allocate on the heap heapSizeMax = trackHeapSize + totalSize + MIN_HEAP_SIZE; } if (heapSizeMax > trackHeapSize + totalSize + MAX_HEAP_EXCESS) { // Make sure there is never more that MAX_HEAP_EXCESS space on the heap heapSizeMax = trackHeapSize + totalSize + MAX_HEAP_EXCESS; } } pHeapEntry = (tHeapEntry *)Mem.malloc(totalSize); pHeapEntry->pTypeDef = pTypeDef; pHeapEntry->signature = VALID_HEAP_OBJ_SIG; pHeapEntry->pSync = null; pHeapEntry->needToFinalize = (byte)((pTypeDef->pFinalizer != null) ? 1 : 0); pMem = (byte *)pHeapEntry + sizeof(tHeapEntry); Mem.memset(pMem, 0, size); trackHeapSize += totalSize; pHeapTreeRoot = TreeInsert(pHeapTreeRoot, pHeapEntry); numNodes++; return(pMem); }
public static tMetaData *GetMetaDataForLoadedAssembly(byte *pLoadedAssemblyName) { tFilesLoaded *pFiles = pFilesLoaded; while (pFiles != null) { tCLIFile * pCLIFile = pFiles->pCLIFile; tMD_Assembly *pThisAssembly = (tMD_Assembly *)MetaData.GetTableRow(pCLIFile->pMetaData, MetaData.MAKE_TABLE_INDEX(0x20, 1)); if (S.strcmp(pLoadedAssemblyName, pThisAssembly->name) == 0) { // Found the correct assembly, so return its meta-data return(pCLIFile->pMetaData); } pFiles = pFiles->pNext; } Sys.Crash("Assembly %s is not loaded\n", (PTR)pLoadedAssemblyName); return(null); }
public static tCLIFile *LoadAssembly(/*char**/ byte *pFileName) { byte[] rawData; tCLIFile * pRet; tFilesLoaded *pNewFile; byte * filepath = stackalloc byte[512]; tMD_Assembly *pThisAssembly = null; rawData = null; for (int i = 0; i < assemblySearchPathsCount; i++) { S.snprintf(filepath, 512, "%s/%s", (PTR)assemblySearchPaths[i], (PTR)pFileName); rawData = LoadFileFromDisk(filepath); if (rawData != null) { break; } } if (rawData == null) { Sys.Crash("Unable to load assembly file %s", (PTR)pFileName); } Sys.log_f(1, "\nLoading file: %s\n", (PTR)pFileName); pRet = LoadPEFile(rawData); // Get the assembly info - there is only ever one of these in the each file's metadata pThisAssembly = (tMD_Assembly *)MetaData.GetTableRow(pRet->pMetaData, MetaData.MAKE_TABLE_INDEX(0x20, 1)); int nameLen = S.strlen(pThisAssembly->name) + 1; pRet->assemblyName = (byte *)Mem.mallocForever((uint)nameLen); S.strncpy(pRet->assemblyName, pThisAssembly->name, nameLen); // Record that we've loaded this file pNewFile = ((tFilesLoaded *)Mem.mallocForever((SIZE_T)sizeof(tFilesLoaded))); pNewFile->pCLIFile = pRet; pNewFile->pNext = pFilesLoaded; pFilesLoaded = pNewFile; return(pRet); }
public static tMD_TypeDef *GetTypeDefFromName(tMetaData *pMetaData, /*STRING*/ byte *nameSpace, /*STRING*/ byte *name, tMD_TypeDef *pInNestedClass, byte assertExists) { uint i, numRows; tMD_TypeDef *pTypeDef = null; numRows = pMetaData->tables.numRows[MetaDataTable.MD_TABLE_TYPEDEF]; for (i = 1; i <= numRows; i++) { pTypeDef = (tMD_TypeDef *)MetaData.GetTableRow(pMetaData, MetaData.MAKE_TABLE_INDEX(MetaDataTable.MD_TABLE_TYPEDEF, i)); if (pInNestedClass == pTypeDef->pNestedIn && S.strcmp(name, pTypeDef->name) == 0 && (pInNestedClass != null || S.strcmp(nameSpace, pTypeDef->nameSpace) == 0)) { return(pTypeDef); } } if (pMetaData->ppChildMetaData != null) { i = 0; while (pMetaData->ppChildMetaData[i] != null) { pTypeDef = GetTypeDefFromName(pMetaData->ppChildMetaData[i], nameSpace, name, pInNestedClass, assertExists); if (pTypeDef != null) { return(pTypeDef); } i++; } } if (assertExists != 0) { Sys.Crash("MetaData.GetTypeDefFromName(): Cannot find type %s.%s", (PTR)nameSpace, (PTR)name); return(null); } else { return(null); } }
public static tMD_TypeDef *FindTypeInAllLoadedAssemblies(/*STRING*/ byte *nameSpace, /*STRING*/ byte *name) { tFilesLoaded *pFiles = pFilesLoaded; while (pFiles != null) { tCLIFile *pCLIFile = pFiles->pCLIFile; tMD_TypeDef *typeDef = MetaData.GetTypeDefFromName(pCLIFile->pMetaData, nameSpace, name, null, /* assertExists */ 0); if (typeDef != null) { return(typeDef); } pFiles = pFiles->pNext; } Sys.Crash("CLIFile_FindTypeInAllLoadedAssemblies(): Cannot find type %s.%s", (PTR)nameSpace, (PTR)name); return(null); }
public static tMD_TypeDef *GetTypeDefFromFieldDef(tMD_FieldDef *pFieldDef) { tMetaData *pMetaData; uint i; pMetaData = pFieldDef->pMetaData; for (i = pMetaData->tables.numRows[MetaDataTable.MD_TABLE_TYPEDEF]; i > 0; i--) { tMD_TypeDef *pTypeDef; pTypeDef = (tMD_TypeDef *)MetaData.GetTableRow(pMetaData, MetaData.MAKE_TABLE_INDEX(MetaDataTable.MD_TABLE_TYPEDEF, i)); if (pTypeDef->fieldList <= pFieldDef->tableIndex) { return(pTypeDef); } } Sys.Crash("MetaData.GetTypeDefFromFieldDef(): Cannot find type for field: %s", (PTR)pFieldDef->name); return(null); }
public static object GetMonoObject(/*HEAP_PTR*/ byte *heapObj) { tHeapEntry *pHeapEntry = GET_HEAPENTRY(heapObj); #if DEBUG_HEAP if (pHeapEntry->signature != VALID_HEAP_OBJ_SIG) { Sys.Crash("Invalid heap object in GetMonoObject()"); } #endif if (pHeapEntry->monoHandle != 0) { void *p = *(void **)heapObj; if (p == null) { return(null); } return(H.ToObj(p)); } return(null); }
public static object GetMonoObject(/*HEAP_PTR*/ byte *heapObj) { tHeapEntry *pHeapEntry = GET_HEAPENTRY(heapObj); #if DEBUG_HEAP if (pHeapEntry->signature != VALID_HEAP_OBJ_SIG) { Sys.Crash("Invalid heap object in GetMonoObject()"); } #endif if (pHeapEntry->monoGCHandle != 0) { void *p = *(void **)heapObj; if (p == null) { return(null); } GCHandle handle = (GCHandle)(System.IntPtr)p; return(handle.Target); } return(null); }
public static void *StackAlloc(tThread *pThread, uint size) { tThreadStack *pStack = pThread->pThreadStack; void * pAddr = pStack->memory + pStack->ofs; #if _DEBUG *(uint *)pAddr = 0xabababab; ((uint *)pAddr)++; pStack->ofs += 4; #endif pStack->ofs += size; if (pStack->ofs > tThreadStack.THREADSTACK_CHUNK_SIZE) { Sys.Crash("Thread-local stack is too large"); } #if _DEBUG Mem.memset(pAddr, 0xcd, size); *(uint *)(((byte *)pAddr) + size) = 0xfbfbfbfb; pStack->ofs += 4; #endif return(pAddr); }
public static tMD_MethodDef *FindInterfaceOverriddenMethod(tMD_MethodDef *pInterfaceMethod, MethodInfo[] interfaceMethods, MethodInfo[] targetMethods) { byte * targetName = stackalloc byte[256]; MethodInfo interfaceMethodInfo = null; for (int i = 0; i < interfaceMethods.Length; i++) { if (S.strcmp(pInterfaceMethod->name, interfaceMethods[i].Name) == 0) { interfaceMethodInfo = targetMethods[i]; break; } } if (interfaceMethodInfo == null) { Sys.Crash("Unable to find mapped method %s", (PTR)(pInterfaceMethod->name)); } S.strncpy(targetName, interfaceMethodInfo.Name, 256); tMD_MethodDef *pOverriddenMethod = null; tMD_TypeDef * pInterfaceTargetType = GetTypeForMonoType(interfaceMethodInfo.DeclaringType, null, null); for (int i = 0; i < pInterfaceTargetType->numMethods; i++) { tMD_MethodDef *pMethodDef = pInterfaceTargetType->ppMethods[i]; MethodInfo methodInfo = H.ToObj(pMethodDef->monoMethodInfo) as MethodInfo; if (methodInfo == interfaceMethodInfo) { return(pInterfaceTargetType->ppMethods[i]); } else if (MetaData.CompareNameAndMethodInfo(targetName, interfaceMethodInfo, pInterfaceMethod->pMetaData, pInterfaceMethod->pParentType->ppClassTypeArgs, pInterfaceMethod->ppMethodTypeArgs, pMethodDef, pMethodDef->pParentType->ppClassTypeArgs, null) != 0) { return(pInterfaceTargetType->ppMethods[i]); } } return(null); }
//[System.Diagnostics.Conditional("CHECK_HEAP")] public static void heapcheck() { if (Sys.isCrashed == 1) { return; } byte *p = pMem; byte *e = pMem + memUsed; for (;;) { if (*(ulong *)p != HEAP_DEAD_BEEF) { Sys.Crash("ERROR: Heap corruption detected!"); } if (p >= e) { break; } uint size = *(uint *)(p + 8); SIZE_T realSize = 16 + ((size + 7) & 0xFFFFFFF8); p += realSize; } }
public static void Fill_TypeDef(tMD_TypeDef *pTypeDef, tMD_TypeDef **ppClassTypeArgs, tMD_TypeDef **ppMethodTypeArgs, uint resolve = Type.TYPE_FILL_ALL) { uint instanceMemSize, staticMemSize, virtualOfs, isDeferred, i, j; int lastPeriod; tMetaData * pMetaData; tMD_TypeDef *pParent; System.Type monoType; tMD_FieldDef * pFieldDefs; tMD_MethodDef *pMethodDefs; FieldInfo[] fieldInfos = null; FieldInfo fieldInfo; MethodInfo[] methodInfos = null; ConstructorInfo[] constructorInfos = null; MethodBase methodBase; tMD_MethodDef * pMethodDef; if (pTypeDef->fillState >= resolve) { return; } if (pTypeDef->monoType == null) { MetaData.Fill_TypeDef(pTypeDef, ppClassTypeArgs, ppMethodTypeArgs, resolve); return; } //Sys.printf("FILLING TYPE: %s\n", (PTR)pTypeDef->name); if (MetaData.typesToFill == null) { MetaData.Fill_StartDefer(); isDeferred = 1; } else { isDeferred = 0; } if (resolve < Type.TYPE_FILL_ALL) { MetaData.Fill_Defer(pTypeDef, ppClassTypeArgs, ppMethodTypeArgs); } MetaData.Fill_GetDeferredTypeArgs(pTypeDef, ref ppClassTypeArgs, ref ppMethodTypeArgs); monoType = H.ToObj(pTypeDef->monoType) as System.Type; pMetaData = pTypeDef->pMetaData; if (pTypeDef->fillState < Type.TYPE_FILL_PARENTS) { pTypeDef->fillState = Type.TYPE_FILL_PARENTS; // For Methods, we get only public if sealed, or public/protected if not sealed methodInfos = GetMethods(monoType); // For fields, we only get private fields for value types fieldInfos = GetFields(monoType); // For constructors, we get only public if sealed, or public/protected if not sealed constructorInfos = GetConstructors(monoType); pTypeDef->pTypeDef = pTypeDef; pTypeDef->pParent = MonoType.GetTypeForMonoType(monoType.BaseType, null, null); pParent = pTypeDef->pParent; pTypeDef->isValueType = (byte)(monoType.IsValueType ? 1 : 0); if (pParent != null) { MetaData.Fill_TypeDef(pParent, null, null, Type.TYPE_FILL_PARENTS); if (pParent->hasMonoBase == 0) { // If we have a mono base type, we have at least 1 non-blittable field pTypeDef->blittable = pParent->blittable; pTypeDef->fixedBlittable = pParent->fixedBlittable; } else { pTypeDef->blittable = pTypeDef->fixedBlittable = 0; } } else { // For mono types - reference types are NEVER blittable in our implementation pTypeDef->blittable = pTypeDef->fixedBlittable = pTypeDef->isValueType; } pTypeDef->alignment = 1; // Mark all ref types as having a base Mono Handle pointer as the first slot in their instance data. This allows // the Heap system to call FREE on this Handle whenever we garbage collect mono wrapped or derived heap objects. pTypeDef->hasMonoBase = (byte)(monoType.IsValueType ? 0 : 1); // If not primed, then work out how many methods & fields there are. if (pTypeDef->isPrimed == 0) { // Methods pTypeDef->numMethods = (uint)(constructorInfos.Length + methodInfos.Length); // Fields pTypeDef->numFields = (uint)fieldInfos.Length; } // If this is an enum type, then pretend its stack type is its underlying type if (pTypeDef->pParent == Type.types[Type.TYPE_SYSTEM_ENUM]) { pTypeDef->stackType = EvalStack.EVALSTACK_INT32; pTypeDef->stackSize = sizeof(PTR); pTypeDef->instanceMemSize = 4; pTypeDef->arrayElementSize = 4; pTypeDef->blittable = pTypeDef->fixedBlittable = 1; } if (pTypeDef->fillState >= resolve) { return; } } else { pParent = pTypeDef->pParent; } if (pTypeDef->fillState < Type.TYPE_FILL_LAYOUT) { pTypeDef->fillState = Type.TYPE_FILL_LAYOUT; if (pParent != null) { if (pParent->fillState < Type.TYPE_FILL_LAYOUT) { MetaData.Fill_TypeDef(pParent, null, null, Type.TYPE_FILL_LAYOUT); } else if (pParent->fillState < Type.TYPE_FILL_ALL) { MetaData.Fill_Defer(pParent, null, null); } } // This only needs to be done for non-generic Type.types, or for generic type that are not a definition // I.e. Fully instantiated generic Type.types if (pTypeDef->isGenericDefinition == 0) { // For fields, we only get private fields for value types if (fieldInfos == null) { fieldInfos = GetFields(monoType); } // Resolve fields, members, interfaces. // Only needs to be done if it's not a generic definition type // It it's not a value-type and the stack-size is not preset, then set it up now. // It needs to be done here as non-static fields in non-value type can point to the containing type if (pTypeDef->stackSize == 0 && pTypeDef->isValueType == 0) { pTypeDef->stackType = EvalStack.EVALSTACK_O; pTypeDef->stackSize = sizeof(PTR); pTypeDef->alignment = sizeof(PTR); } // Resolve all fields - instance ONLY at this point, // because static fields in value-Type.types can be of the containing type, and the size is not yet known. staticMemSize = 0; if (pTypeDef->numFields > 0) { pTypeDef->ppFields = (tMD_FieldDef **)Mem.mallocForever((SIZE_T)(pTypeDef->numFields * sizeof(tMD_FieldDef *))); pFieldDefs = (tMD_FieldDef *)Mem.mallocForever((SIZE_T)(pTypeDef->numFields * sizeof(tMD_FieldDef))); Mem.memset(pFieldDefs, 0, (SIZE_T)(pTypeDef->numFields * sizeof(tMD_FieldDef))); } else { pFieldDefs = null; } instanceMemSize = 0; for (i = 0; i < fieldInfos.Length; i++) { fieldInfo = fieldInfos[i]; tMD_FieldDef *pFieldDef = &pFieldDefs[i]; pFieldDef->name = new S(fieldInfo.Name); pFieldDef->flags = (ushort)( (fieldInfo.IsStatic ? MetaData.FIELDATTRIBUTES_STATIC : 0) | (fieldInfo.IsLiteral ? MetaData.FIELDATTRIBUTES_LITERAL : 0) ); if (!fieldInfo.IsStatic) { if (fieldInfo.IsLiteral /*|| MetaData.FIELD_HASFIELDRVA(pFieldDef)*/) { // If it's a literal, then analyse the field, but don't include it in any memory allocation // If is has an RVA, then analyse the field, but don't include it in any memory allocation MonoType.Fill_FieldDef(pTypeDef, fieldInfo, pFieldDef, 0, null, ppClassTypeArgs); } else { MonoType.Fill_FieldDef(pTypeDef, fieldInfo, pFieldDef, instanceMemSize, &(pTypeDef->alignment), ppClassTypeArgs); instanceMemSize = pFieldDef->memOffset + pFieldDef->memSize; } // Update blittable and fixedBlittable status for type - if any non-blittable fields are included set to 0 if (pTypeDef->blittable != 0 || pTypeDef->fixedBlittable != 0) { if (pFieldDef->pType->isValueType == 0 || pFieldDef->pType->blittable == 0) { pTypeDef->blittable = pTypeDef->fixedBlittable = 0; } else if (pFieldDef->pType->typeInitId == Type.TYPE_SYSTEM_INTPTR || pFieldDef->pType->typeInitId == Type.TYPE_SYSTEM_UINTPTR) { pTypeDef->fixedBlittable = 0; } } pTypeDef->ppFields[i] = pFieldDef; } } if (pTypeDef->instanceMemSize == 0) { if (pTypeDef->isValueType != 0) { // Our dna value types are the same size as they are in mono (hopefully!) pTypeDef->instanceMemSize = (instanceMemSize + (pTypeDef->alignment - 1)) & ~(pTypeDef->alignment - 1); } else { // For mono reference types, the instance size is ALWAYS ptr size because we're wrapping a mono GCHandle pointer pTypeDef->instanceMemSize = sizeof(PTR); } } // Sort out stack type and size. // Note that this may already be set, as some basic type have this preset; // or if it's not a value-type it'll already be set if (pTypeDef->stackSize == 0) { // if it gets here then it must be a value type pTypeDef->stackType = EvalStack.EVALSTACK_VALUETYPE; pTypeDef->stackSize = pTypeDef->instanceMemSize; } // Sort out array element size. Note that some basic type will have this preset. if (pTypeDef->arrayElementSize == 0) { pTypeDef->arrayElementSize = pTypeDef->stackSize; } // Make sure stack size is even multiple of stack alignment pTypeDef->stackSize = (pTypeDef->stackSize + (STACK_ALIGNMENT - 1)) & ~(STACK_ALIGNMENT - 1); // Handle static fields for (i = 0; i < fieldInfos.Length; i++) { fieldInfo = fieldInfos[i]; tMD_FieldDef *pFieldDef = &pFieldDefs[i]; if (fieldInfo.IsStatic) { if (fieldInfo.IsLiteral /*|| MetaData.FIELD_HASFIELDRVA(pFieldDef)*/) { // If it's a literal, then analyse the field, but don't include it in any memory allocation // If is has an RVA, then analyse the field, but don't include it in any memory allocation MonoType.Fill_FieldDef(pTypeDef, fieldInfo, pFieldDef, 0, null, ppClassTypeArgs); } else { MonoType.Fill_FieldDef(pTypeDef, fieldInfo, pFieldDef, staticMemSize, null, ppClassTypeArgs); staticMemSize += pFieldDef->memSize; } pTypeDef->ppFields[i] = pFieldDef; } } } if (pTypeDef->fillState >= resolve) { return; } } if (pTypeDef->fillState < Type.TYPE_FILL_VTABLE) { pTypeDef->fillState = Type.TYPE_FILL_VTABLE; if (pParent != null) { if (pParent->fillState < Type.TYPE_FILL_VTABLE) { MetaData.Fill_TypeDef(pParent, null, null, Type.TYPE_FILL_VTABLE); } else if (pParent->fillState < Type.TYPE_FILL_ALL) { MetaData.Fill_Defer(pParent, null, null); } } // This only needs to be done for non-generic Type.types, or for generic type that are not a definition // I.e. Fully instantiated generic Type.types if (pTypeDef->isGenericDefinition == 0) { virtualOfs = (pParent != null) ? pParent->numVirtualMethods : 0; // For Methods, we get only public if sealed, or public/protected if not sealed if (methodInfos == null) { methodInfos = GetMethods(monoType); } // For constructors, we get only public if sealed, or public/protected if not sealed if (constructorInfos == null) { constructorInfos = GetConstructors(monoType); } // Populate methods pTypeDef->ppMethods = (tMD_MethodDef **)Mem.mallocForever((SIZE_T)(pTypeDef->numMethods * sizeof(tMD_MethodDef *))); pMethodDefs = (tMD_MethodDef *)Mem.mallocForever((SIZE_T)(pTypeDef->numMethods * sizeof(tMD_MethodDef))); Mem.memset(pMethodDefs, 0, (SIZE_T)(pTypeDef->numMethods * sizeof(tMD_MethodDef))); for (i = 0; i < pTypeDef->numMethods; i++) { methodBase = (i < constructorInfos.Length) ? (MethodBase)constructorInfos[i] : methodInfos[i - constructorInfos.Length]; pMethodDef = &pMethodDefs[i]; lastPeriod = methodBase.Name.LastIndexOf('.'); if (methodBase is ConstructorInfo || lastPeriod == -1) { pMethodDef->name = new S(methodBase.Name); } else { string nameMinusExclInterfaceName = methodBase.Name.Substring(lastPeriod + 1); pMethodDef->name = new S(nameMinusExclInterfaceName); } pMethodDef->monoMethodInfo = new H(methodBase); pMethodDef->pMetaData = pMetaData; pMethodDef->pParentType = pTypeDef; pMethodDef->flags = (ushort)( (methodBase.IsVirtual ? MetaData.METHODATTRIBUTES_VIRTUAL : 0) | (methodBase.IsStatic ? MetaData.METHODATTRIBUTES_STATIC : 0)); // NOTE: All mono calls are considered internal calls pMethodDef->implFlags = (ushort)MetaData.METHODIMPLATTRIBUTES_INTERNALCALL; pTypeDef->ppMethods[i] = pMethodDef; // Assign vtable slots if (methodBase.IsVirtual) { if (((MethodInfo)methodBase).GetBaseDefinition().DeclaringType == monoType) { // Allocate a new vTable slot if method is explicitly marked as NewSlot, or // this is of type Object. pMethodDef->vTableOfs = virtualOfs++; } else { tMD_MethodDef *pVirtualOveriddenMethod; pVirtualOveriddenMethod = MetaData.FindVirtualOverriddenMethod(pTypeDef->pParent, pMethodDef); if (pVirtualOveriddenMethod == null) { if (pTypeDef->pParent->monoType == null) { // DNA types don't always have all base methods that Unity/Mono has. In those // cases, just add the missing method to the VTable as a new virtual method. pMethodDef->vTableOfs = virtualOfs++; } else { Sys.Crash("Unable to find virtual override %s", (PTR)(pMethodDef->name)); } } else { pMethodDef->vTableOfs = pVirtualOveriddenMethod->vTableOfs; } } } else { // Dummy value - make it obvious it's not valid! pMethodDef->vTableOfs = 0xffffffff; } pTypeDef->ppMethods[i] = pMethodDef; } // Create the virtual method table pTypeDef->numVirtualMethods = virtualOfs; // Resolve all members pTypeDef->pVTable = (tMD_MethodDef **)Mem.mallocForever((SIZE_T)(pTypeDef->numVirtualMethods * sizeof(tMD_MethodDef *))); // Copy initial vTable from parent if (pTypeDef->pParent != null) { Mem.memcpy(pTypeDef->pVTable, pTypeDef->pParent->pVTable, (SIZE_T)(pTypeDef->pParent->numVirtualMethods * sizeof(tMD_MethodDef *))); } for (i = 0; i < pTypeDef->numMethods; i++) { pMethodDef = pTypeDef->ppMethods[i]; methodBase = H.ToObj(pMethodDef->monoMethodInfo) as MethodBase; if (methodBase.IsStatic && methodBase.Name == ".cctor") { // This is a static constructor pTypeDef->pStaticConstructor = pMethodDef; } if (methodBase.IsStatic && pTypeDef->pParent != null && methodBase.Name == "Finalize") { // This is a Finalizer method, but not for Object. // Delibrately miss out Object's Finalizer because it's empty and will cause every object // of any type to have a Finalizer which will be terrible for performance. pTypeDef->pFinalizer = pMethodDef; } if (methodBase.IsVirtual) { if (pMethodDef->vTableOfs == 0xffffffff) { Sys.Crash("Illegal vtableoffset"); } if (pMethodDef->vTableOfs >= pTypeDef->numVirtualMethods) { Sys.Crash("Illegal vtableoffset"); } pTypeDef->pVTable[pMethodDef->vTableOfs] = pMethodDef; } } // Find inherited Finalizer, if this type doesn't have an explicit Finalizer, and if there is one if (pTypeDef->pFinalizer == null) { tMD_TypeDef *pInheritedType = pTypeDef->pParent; while (pInheritedType != null) { if (pInheritedType->pFinalizer != null) { pTypeDef->pFinalizer = pInheritedType->pFinalizer; break; } pInheritedType = pInheritedType->pParent; } } } if (pTypeDef->fillState >= resolve) { return; } } if (pTypeDef->fillState < Type.TYPE_FILL_MEMBERS) { pTypeDef->fillState = Type.TYPE_FILL_MEMBERS; if (pParent != null) { if (pParent->fillState < Type.TYPE_FILL_MEMBERS) { MetaData.Fill_TypeDef(pParent, null, null, Type.TYPE_FILL_MEMBERS); } else if (pParent->fillState < Type.TYPE_FILL_ALL) { MetaData.Fill_Defer(pParent, null, null); } } // This only needs to be done for non-generic Type.types, or for generic type that are not a definition // I.e. Fully instantiated generic Type.types if (pTypeDef->isGenericDefinition == 0) { // Fill all method definitions for this type for (i = 0; i < pTypeDef->numMethods; i++) { pMethodDef = pTypeDef->ppMethods[i]; methodBase = H.ToObj(pMethodDef->monoMethodInfo) as MethodBase; MonoType.Fill_MethodDef(pTypeDef, methodBase, pTypeDef->ppMethods[i], ppClassTypeArgs, ppMethodTypeArgs); } } if (pTypeDef->fillState >= resolve) { return; } } if (pTypeDef->fillState < Type.TYPE_FILL_INTERFACES) { pTypeDef->fillState = Type.TYPE_FILL_INTERFACES; if (pParent != null) { if (pParent->fillState < Type.TYPE_FILL_INTERFACES) { MetaData.Fill_TypeDef(pParent, null, null, Type.TYPE_FILL_INTERFACES); } else if (pParent->fillState < Type.TYPE_FILL_ALL) { MetaData.Fill_Defer(pParent, null, null); } } // This only needs to be done for non-generic Type.types, or for generic type that are not a definition // I.e. Fully instantiated generic Type.types if (pTypeDef->isGenericDefinition == 0) { // Map all interface method calls. This only needs to be done for Classes, not Interfaces // And is not done for generic definitions. if (!monoType.IsInterface) { System.Type[] interfaceTypes = monoType.GetInterfaces(); pTypeDef->numInterfaces = (uint)interfaceTypes.Length; if (interfaceTypes.Length > 0 && pTypeDef->isGenericDefinition == 0) { if (pTypeDef->pInterfaceMaps == null) { pTypeDef->pInterfaceMaps = (tInterfaceMap *)Mem.mallocForever((SIZE_T)(pTypeDef->numInterfaces * sizeof(tInterfaceMap))); } for (i = 0; i < interfaceTypes.Length; i++) { // Get the interface that this type implements tMD_TypeDef *pInterface = MonoType.GetTypeForMonoType(interfaceTypes[i], ppClassTypeArgs, ppMethodTypeArgs); Fill_TypeDef(pInterface, ppClassTypeArgs, null, Type.TYPE_FILL_VTABLE); InterfaceMapping interfaceMapping = monoType.GetInterfaceMap(interfaceTypes[i]); MetaData.Fill_TypeDef(pInterface, null, null); tInterfaceMap *pMap = &pTypeDef->pInterfaceMaps[i]; pMap->pInterface = pInterface; pMap->pVTableLookup = (uint *)Mem.mallocForever((SIZE_T)(pInterface->numVirtualMethods * sizeof(uint))); pMap->ppMethodVLookup = (tMD_MethodDef **)Mem.mallocForever((SIZE_T)(pInterface->numVirtualMethods * sizeof(tMD_MethodDef *))); MethodInfo[] interfaceMethods = interfaceMapping.InterfaceMethods; MethodInfo[] targetMethods = interfaceMapping.TargetMethods; // Discover interface mapping for each interface method for (j = 0; j < pInterface->numVirtualMethods; j++) { tMD_MethodDef *pInterfaceMethod = pInterface->pVTable[j]; tMD_MethodDef *pOverriddenMethod = FindInterfaceOverriddenMethod(pInterfaceMethod, interfaceMethods, targetMethods); if (pOverriddenMethod == null) { Sys.Crash("Unable to find override method %s in type %s.%s for interface %s.%s", (PTR)(pInterfaceMethod->name), (PTR)pTypeDef->nameSpace, (PTR)pTypeDef->name, (PTR)pInterface->nameSpace, (PTR)pInterface->name); } pMap->pVTableLookup[j] = pOverriddenMethod->vTableOfs; pMap->ppMethodVLookup[j] = pOverriddenMethod; } } } } } if (pTypeDef->fillState >= resolve) { return; } } if (pTypeDef->fillState < Type.TYPE_FILL_ALL) { pTypeDef->fillState = Type.TYPE_FILL_ALL; if (pParent != null && pParent->fillState < Type.TYPE_FILL_ALL) { MetaData.Fill_TypeDef(pParent, null, null, Type.TYPE_FILL_ALL); } if (isDeferred != 0) { MetaData.Fill_ResolveDeferred(); } } Sys.log_f(2, "Mono Type: %s.%s\n", (PTR)pTypeDef->nameSpace, (PTR)pTypeDef->name); }
public static void LoadTables(tMetaData *pThis, tRVA *pRVA, void *pStream, uint streamLen) { ulong valid, j; byte c; int i, k, numTables; void *pTable; c = *(byte *)&((byte *)pStream)[6]; pThis->index32BitString = (c & 1) > 0 ? (byte)1 : (byte)0; pThis->index32BitGUID = (c & 2) > 0 ? (byte)1 : (byte)0; pThis->index32BitBlob = (c & 4) > 0 ? (byte)1 : (byte)0; valid = *(ulong *)&((byte *)pStream)[8]; // Count how many tables there are, and read in all the number of rows of each table. numTables = 0; for (i = 0, j = 1; i < MAX_TABLES; i++, j <<= 1) { if ((valid & j) != 0) { pThis->tables.numRows[i] = *(uint *)&((byte *)pStream)[24 + numTables * 4]; numTables++; } else { pThis->tables.numRows[i] = 0; pThis->tables.data[i] = /*null*/ 0; } } // Determine if each coded index lookup type needs to use 16 or 32 bit indexes for (i = 0; i < 13; i++) { /*char*/ byte *pCoding = codedTags[i]; int tagBits = codedTagBits[i]; // Discover max table size uint maxTableLen = 0; for (k = 0; k < (1 << tagBits); k++) { byte t = pCoding[k]; if (t != 'z') { if (pThis->tables.numRows[t] > maxTableLen) { maxTableLen = pThis->tables.numRows[t]; } } } if (maxTableLen < (uint)(1 << (16 - tagBits))) { // Use 16-bit number pThis->tables.codedIndex32Bit[i] = 0; } else { // Use 32-bit number pThis->tables.codedIndex32Bit[i] = 1; } } pTable = &((byte *)pStream)[24 + numTables * 4]; for (i = 0; i < MAX_TABLES; i++) { if (pThis->tables.numRows[i] > 0) { if (i >= TABLEDEFS_LENGTH || tableDefs[i] == null) { Sys.Crash("No table definition for MetaData table 0x%02x\n", i); } pThis->tables.data[i] = (PTR)LoadSingleTable(pThis, pRVA, i, &pTable); } } }
// Loads a single table, returns pointer to table in memory. public static void *LoadSingleTable(tMetaData *pThis, tRVA *pRVA, int tableID, void **ppTable) { int numRows = (int)pThis->tables.numRows[tableID]; int rowLen = tableRowSize[tableID]; int i, row; /*char**/ byte *pDef = tableDefs[tableID]; int defLen = (int)S.strlen(pDef); void * pRet; byte * pSource = (byte *)*ppTable; byte * pDest; uint v = 0; SIZE_T p = 0; // Allocate memory for destination table pRet = Mem.malloc((SIZE_T)(numRows * rowLen)); pDest = (byte *)pRet; // Load table int srcLen = 0; for (row = 0; row < numRows; row++) { byte *pSrcStart = pSource; for (i = 0; i < defLen; i += 2) { byte d = pDef[i]; if (d < MAX_TABLES) { if (pThis->tables.numRows[d] < 0x10000) { // Use 16-bit offset v = GetU16(pSource); pSource += 2; } else { // Use 32-bit offset v = GetU32(pSource); pSource += 4; } v |= (uint)d << 24; } else { switch ((char)d) { case 'c': // 8-bit value v = *(byte *)pSource; pSource++; break; case 's': // 16-bit short v = GetU16(pSource); pSource += 2; break; case 'i': // 32-bit int v = GetU32(pSource); pSource += 4; break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case ':': case ';': case '<': { int ofs = pDef[i] - '0'; /*char*/ byte *pCoding = codedTags[ofs]; int tagBits = codedTagBits[ofs]; byte tag = (byte)(*pSource & ((1 << tagBits) - 1)); int idxIntoTableID = pCoding[tag]; // The actual table index that we're looking for if (idxIntoTableID < 0 || idxIntoTableID > MAX_TABLES) { Sys.Crash("Error: Bad table index: 0x%02x\n", idxIntoTableID); } if (pThis->tables.codedIndex32Bit[ofs] != 0) { // Use 32-bit number v = GetU32(pSource) >> tagBits; pSource += 4; } else { // Use 16-bit number v = GetU16(pSource) >> tagBits; pSource += 2; } v |= (uint)idxIntoTableID << 24; } break; case 'S': // index into string heap if (pThis->index32BitString != 0) { v = GetU32(pSource); pSource += 4; } else { v = GetU16(pSource); pSource += 2; } p = (PTR)(pThis->strings.pStart + v); // NOTE: Quick way to validate metadata loading, check if all strings are valid! if (S.isvalidstr((byte *)p) == 0) { Sys.Crash("Invalid string %s", (PTR)p); } break; case 'G': // index into GUID heap if (pThis->index32BitGUID != 0) { v = GetU32(pSource); pSource += 4; } else { v = GetU16(pSource); pSource += 2; } p = (PTR)(pThis->GUIDs.pGUID1 + ((v - 1) * 16)); break; case 'B': // index into BLOB heap if (pThis->index32BitBlob != 0) { v = GetU32(pSource); pSource += 4; } else { v = GetU16(pSource); pSource += 2; } p = (PTR)(pThis->blobs.pStart + v); break; case '^': // RVA to convert to pointer v = GetU32(pSource); pSource += 4; p = (PTR)RVA.FindData(pRVA, v); break; case 'm': // Pointer to this metadata p = (PTR)pThis; break; case 'l': // Is this the last table entry? v = (row == numRows - 1) ? (uint)1 : (uint)0; break; case 'I': // Original table index v = MetaData.MAKE_TABLE_INDEX((uint)tableID, (uint)(row + 1)); break; case 'x': // Nothing, use 0 v = 0; p = 0; break; default: Sys.Crash("Cannot handle MetaData source definition character '%c' (0x%02X)\n", d, d); break; } } switch ((char)pDef[i + 1]) { case '*': *(SIZE_T *)pDest = p; pDest += sizeof(SIZE_T); break; case 'i': *(uint *)pDest = v; pDest += 4; break; case 's': *(ushort *)pDest = (ushort)v; pDest += 2; break; case 'c': *(byte *)pDest = (byte)v; pDest++; break; case 'x': // Do nothing break; default: Sys.Crash("Cannot handle MetaData destination definition character '%c'\n", pDef[i + 1]); break; } } if (srcLen == 0) { srcLen = (int)(pSource - pSrcStart); } } Sys.log_f(1, "Loaded MetaData table 0x%02X; %d rows %d len\n", tableID, numRows, srcLen); // Update the parameter to the position after this table *ppTable = pSource; // Return new table information return(pRet); }
public static tMD_MethodDef *GetMethodDefFromDefRefOrSpec(tMetaData *pMetaData, /*IDX_TABLE*/ uint token, tMD_TypeDef **ppClassTypeArgs, tMD_TypeDef **ppMethodTypeArgs) { void *pTableEntry; pTableEntry = MetaData.GetTableRow(pMetaData, token); if (((tMDC_ToMethodDef *)pTableEntry)->pMethodDef != null) { return(((tMDC_ToMethodDef *)pTableEntry)->pMethodDef); } switch (MetaData.TABLE_ID(token)) { case MetaDataTable.MD_TABLE_METHODDEF: ((tMDC_ToMethodDef *)pTableEntry)->pMethodDef = (tMD_MethodDef *)pTableEntry; return((tMD_MethodDef *)pTableEntry); case MetaDataTable.MD_TABLE_MEMBERREF: { tMD_MemberRef *pMemberRef; pMemberRef = (tMD_MemberRef *)pTableEntry; switch (MetaData.TABLE_ID(pMemberRef->class_)) { case MetaDataTable.MD_TABLE_TYPEREF: case MetaDataTable.MD_TABLE_TYPESPEC: { tMD_TypeDef * pTypeDef; tMD_MethodDef *pMethodDef; pTypeDef = MetaData.GetTypeDefFromDefRefOrSpec(pMetaData, pMemberRef->class_, ppClassTypeArgs, ppMethodTypeArgs); MetaData.Fill_TypeDef(pTypeDef, null, null); pMethodDef = FindMethodInType(pTypeDef, pMemberRef->name, pMetaData, pMemberRef->signature, pTypeDef->ppClassTypeArgs, ppMethodTypeArgs); //pMethodDef->pMethodDef = pMethodDef; return(pMethodDef); } default: Sys.Crash("MetaData.GetMethodDefFromMethodDefOrRef(): Cannot handle pMemberRef->class_=0x%08x", pMemberRef->class_); return(null); } } case MetaDataTable.MD_TABLE_METHODSPEC: { tMD_MethodSpec *pMethodSpec; tMD_MethodDef * pMethodDef; pMethodSpec = (tMD_MethodSpec *)pTableEntry; pMethodDef = Generics.GetMethodDefFromSpec(pMethodSpec, ppClassTypeArgs, ppMethodTypeArgs); // Note: Cannot cache the MethodDef from the MethodSpec, as class generic arguments // may be different. return(pMethodDef); } } Sys.Crash("MetaData.GetMethodDefFromMethodDefOrRef(): Cannot handle token: 0x%08x", token); return(null); }
// Return pointer to the relevant Def structure. // pObjectType returns: // 0 - tMD_TypeDef // 1 - tMD_MethodDef // 2 - tMD_FieldDef // (These link up with the JitOps.JIT_LOADTOKEN_* opcodes) public static byte *GetTypeMethodField(tMetaData *pMetaData, /*IDX_TABLE*/ uint token, uint *pObjectType, tMD_TypeDef **ppClassTypeArgs, tMD_TypeDef **ppMethodTypeArgs) { switch (MetaData.TABLE_ID(token)) { case MetaDataTable.MD_TABLE_TYPEDEF: case MetaDataTable.MD_TABLE_TYPEREF: case MetaDataTable.MD_TABLE_TYPESPEC: { tMD_TypeDef *pTypeDef; pTypeDef = MetaData.GetTypeDefFromDefRefOrSpec(pMetaData, token, ppClassTypeArgs, ppMethodTypeArgs); //MetaData.Fill_TypeDef(pTypeDef, null, null); *pObjectType = 0; return((byte *)pTypeDef); } case MetaDataTable.MD_TABLE_METHODDEF: method: { tMD_MethodDef *pMethodDef; pMethodDef = MetaData.GetMethodDefFromDefRefOrSpec(pMetaData, token, ppClassTypeArgs, ppMethodTypeArgs); if (pMethodDef->isFilled == 0) { tMD_TypeDef *pTypeDef; pTypeDef = MetaData.GetTypeDefFromMethodDef(pMethodDef); //MetaData.Fill_TypeDef(pTypeDef, null, null); } *pObjectType = 1; return((byte *)pMethodDef); } case MetaDataTable.MD_TABLE_FIELDDEF: field: { tMD_FieldDef *pFieldDef; pFieldDef = MetaData.GetFieldDefFromDefOrRef(pMetaData, token, ppClassTypeArgs, ppMethodTypeArgs); if (pFieldDef->pParentType == null) { tMD_TypeDef *pTypeDef; pTypeDef = MetaData.GetTypeDefFromFieldDef(pFieldDef); //MetaData.Fill_TypeDef(pTypeDef, null, null); } *pObjectType = 2; return((byte *)pFieldDef); } case MetaDataTable.MD_TABLE_MEMBERREF: { tMD_MemberRef *pMemberRef; /*SIG*/ byte * sig; pMemberRef = (tMD_MemberRef *)MetaData.GetTableRow(pMetaData, token); sig = MetaData.GetBlob(pMemberRef->signature, null); if (*(byte *)sig == 0x06) { // Field goto field; } else { // Method goto method; } } } Sys.Crash("MetaData.GetTypeMethodField(): Cannot handle token: 0x%08x", token); return(null); }
public static void Fill_TypeDef(tMD_TypeDef *pTypeDef, tMD_TypeDef **ppClassTypeArgs, tMD_TypeDef **ppMethodTypeArgs, uint resolve = Type.TYPE_FILL_ALL) { /*IDX_TABLE*/ uint firstIdx, lastIdx, token; uint instanceMemSize, staticMemSize, virtualOfs, isDeferred, i, j; tMetaData * pMetaData = pTypeDef->pMetaData; tMD_TypeDef *pParent; if (pTypeDef->fillState >= resolve) { return; } if (pTypeDef->monoType != null) { MonoType.Fill_TypeDef(pTypeDef, ppClassTypeArgs, ppMethodTypeArgs, resolve); return; } // Sys.printf("FILLING TYPE: %s\n", (PTR)pTypeDef->name); // string name = System.Runtime.InteropServices.Marshal.PtrToStringAnsi((System.IntPtr)pTypeDef->name); if (typesToFill == null) { Fill_StartDefer(); isDeferred = 1; } else { isDeferred = 0; } if (resolve < Type.TYPE_FILL_ALL) { MetaData.Fill_Defer(pTypeDef, ppClassTypeArgs, ppMethodTypeArgs); } MetaData.Fill_GetDeferredTypeArgs(pTypeDef, ref ppClassTypeArgs, ref ppMethodTypeArgs); // Fill parent info if (pTypeDef->fillState < Type.TYPE_FILL_PARENTS) { pTypeDef->fillState = Type.TYPE_FILL_PARENTS; pTypeDef->pTypeDef = pTypeDef; if (pTypeDef->alignment == 0) { pTypeDef->alignment = 1; } if (pTypeDef->pParent == null) { pTypeDef->pParent = MetaData.GetTypeDefFromDefRefOrSpec(pMetaData, pTypeDef->extends, ppClassTypeArgs, ppMethodTypeArgs); } pParent = pTypeDef->pParent; if (pParent != null) { if (pParent->fillState < Type.TYPE_FILL_PARENTS) { MetaData.Fill_TypeDef(pParent, null, null, Type.TYPE_FILL_PARENTS); } else if (pParent->fillState < Type.TYPE_FILL_ALL) { MetaData.Fill_Defer(pParent, null, null); } pTypeDef->hasMonoBase = pParent->hasMonoBase; if (pParent->hasMonoBase == 0) { // If we have a mono base type, we have at least 1 non-blittable field pTypeDef->blittable = pParent->blittable; pTypeDef->fixedBlittable = pParent->fixedBlittable; } else { pTypeDef->blittable = pTypeDef->fixedBlittable = 0; } } else { pTypeDef->blittable = pTypeDef->fixedBlittable = 1; } // If this type is an interface, then return 0 if (pTypeDef->stackSize != 0) { pTypeDef->isValueType = (byte)(pTypeDef->stackType != EvalStack.EVALSTACK_O ? 1 : 0); } else if (MetaData.TYPE_ISINTERFACE(pTypeDef)) { pTypeDef->isValueType = 0; } else if (pTypeDef->nameSpace[0] == 'S' && S.strcmp(pTypeDef->nameSpace, new S(ref scSystem, "System")) == 0) { if ((pTypeDef->name[0] == 'V' && S.strcmp(pTypeDef->name, new S(ref scValueType, "ValueType")) == 0) || (pTypeDef->name[0] == 'E' && S.strcmp(pTypeDef->name, new S(ref scEnum, "Enum")) == 0)) { pTypeDef->isValueType = 1; } else if (pTypeDef->name[0] == 'O' && S.strcmp(pTypeDef->name, new S(ref scObject, "Object")) == 0) { pTypeDef->isValueType = 0; } else if (pParent != null) { pTypeDef->isValueType = pParent->isValueType; } } else if (pParent != null) { pTypeDef->isValueType = pParent->isValueType; } // If not primed, then work out how many methods & fields there are. if (pTypeDef->isPrimed == 0) { // Methods lastIdx = (pTypeDef->isLast != 0) ? MetaData.MAKE_TABLE_INDEX(MetaDataTable.MD_TABLE_METHODDEF, pTypeDef->pMetaData->tables.numRows[MetaDataTable.MD_TABLE_METHODDEF]) : (pTypeDef[1].methodList - 1); pTypeDef->numMethods = lastIdx - pTypeDef->methodList + 1; // Fields lastIdx = (pTypeDef->isLast != 0) ? MetaData.MAKE_TABLE_INDEX(MetaDataTable.MD_TABLE_FIELDDEF, pTypeDef->pMetaData->tables.numRows[MetaDataTable.MD_TABLE_FIELDDEF]) : (pTypeDef[1].fieldList - 1); pTypeDef->numFields = lastIdx - pTypeDef->fieldList + 1; } // If this is a nested type, then find the namespace of it if (pTypeDef->pNestedIn != null) { tMD_TypeDef *pRootTypeDef = pTypeDef->pNestedIn; while (pRootTypeDef->pNestedIn != null) { pRootTypeDef = pRootTypeDef->pNestedIn; } pTypeDef->nameSpace = pRootTypeDef->nameSpace; } // If this is an enum type, then pretend its stack type is its underlying type if (pTypeDef->pParent == Type.types[Type.TYPE_SYSTEM_ENUM]) { pTypeDef->stackType = EvalStack.EVALSTACK_INT32; pTypeDef->stackSize = sizeof(PTR); pTypeDef->instanceMemSize = 4; pTypeDef->arrayElementSize = 4; pTypeDef->blittable = pTypeDef->fixedBlittable = 1; } if (pTypeDef->fillState >= resolve) { return; } } else { pParent = pTypeDef->pParent; } if (pTypeDef->fillState < Type.TYPE_FILL_LAYOUT) { pTypeDef->fillState = Type.TYPE_FILL_LAYOUT; if (pParent != null) { if (pParent->fillState < Type.TYPE_FILL_LAYOUT) { MetaData.Fill_TypeDef(pParent, null, null, Type.TYPE_FILL_LAYOUT); } else if (pParent->fillState < Type.TYPE_FILL_ALL) { MetaData.Fill_Defer(pParent, null, null); } } if (pTypeDef->isGenericDefinition == 0) { // Resolve fields, members, interfaces. // Only needs to be done if it's not a generic definition type // It it's not a value-type and the stack-size is not preset, then set it up now. // It needs to be done here as non-static fields in non-value type can point to the containing type if (pTypeDef->stackSize == 0 && pTypeDef->isValueType == 0) { pTypeDef->stackType = EvalStack.EVALSTACK_O; pTypeDef->stackSize = sizeof(PTR); pTypeDef->alignment = sizeof(PTR); } // Resolve all fields - instance ONLY at this point, // because static fields in value-Type.types can be of the containing type, and the size is not yet known. firstIdx = pTypeDef->fieldList; lastIdx = firstIdx + pTypeDef->numFields - 1; staticMemSize = 0; if (pTypeDef->numFields > 0) { pTypeDef->ppFields = (tMD_FieldDef **)Mem.mallocForever((SIZE_T)(pTypeDef->numFields * sizeof(tMD_FieldDef *))); } instanceMemSize = (pParent == null ? 0 : pTypeDef->pParent->instanceMemSize); if (pTypeDef->hasMonoBase != 0 && pParent->hasMonoBase == 0) { // Some DNA types like String are actually wrappers around mono objects. In those cases, we need to allocate the // space in the instance memory for the GCHandle to the mono object. We distinguish this case from the case // where we're just extending a Mono Type object by checking if the parent also has the hasMonoBase flag set. instanceMemSize += (uint)sizeof(void *); } for (token = firstIdx, i = 0; token <= lastIdx; token++, i++) { tMD_FieldDef *pFieldDef; pFieldDef = MetaData.GetFieldDefFromDefOrRef(pMetaData, token, ppClassTypeArgs, ppMethodTypeArgs); if (!MetaData.FIELD_ISSTATIC(pFieldDef)) { // Only handle non-static fields at the moment if (pTypeDef->pGenericDefinition != null) { // If this is a generic instantiation type, then all field defs need to be copied, // as there will be lots of different instantiations. tMD_FieldDef *pFieldCopy = ((tMD_FieldDef *)Mem.mallocForever((SIZE_T)sizeof(tMD_FieldDef))); Mem.memcpy(pFieldCopy, pFieldDef, (SIZE_T)sizeof(tMD_FieldDef)); pFieldDef = pFieldCopy; } if (MetaData.FIELD_ISLITERAL(pFieldDef) || MetaData.FIELD_HASFIELDRVA(pFieldDef)) { // If it's a literal, then analyse the field, but don't include it in any memory allocation // If is has an RVA, then analyse the field, but don't include it in any memory allocation MetaData.Fill_FieldDef(pTypeDef, pFieldDef, 0, null, ppClassTypeArgs); } else { MetaData.Fill_FieldDef(pTypeDef, pFieldDef, instanceMemSize, &(pTypeDef->alignment), ppClassTypeArgs); instanceMemSize = pFieldDef->memOffset + pFieldDef->memSize; } // Update blittable and fixedBlittable status for type - if any non-blittable fields are included set to 0 if (pTypeDef->blittable != 0 || pTypeDef->fixedBlittable != 0) { if (pFieldDef->pType->isValueType == 0 || pFieldDef->pType->blittable == 0) { pTypeDef->blittable = pTypeDef->fixedBlittable = 0; } else if (pFieldDef->pType->typeInitId == Type.TYPE_SYSTEM_INTPTR || pFieldDef->pType->typeInitId == Type.TYPE_SYSTEM_UINTPTR) { pTypeDef->fixedBlittable = 0; } } pTypeDef->ppFields[i] = pFieldDef; } } if (pTypeDef->instanceMemSize == 0) { pTypeDef->instanceMemSize = (instanceMemSize + (pTypeDef->alignment - 1)) & ~(pTypeDef->alignment - 1); } // Sort out stack type and size. // Note that this may already be set, as some basic type have this preset; // or if it's not a value-type it'll already be set if (pTypeDef->stackSize == 0) { // if it gets here then it must be a value type pTypeDef->stackType = EvalStack.EVALSTACK_VALUETYPE; pTypeDef->stackSize = pTypeDef->instanceMemSize; } // Sort out array element size. Note that some basic type will have this preset. if (pTypeDef->arrayElementSize == 0) { pTypeDef->arrayElementSize = pTypeDef->stackSize; } // Make sure stack size is even multiple of stack alignment pTypeDef->stackSize = (pTypeDef->stackSize + (STACK_ALIGNMENT - 1)) & ~(STACK_ALIGNMENT - 1); // Handle static fields for (token = firstIdx, i = 0; token <= lastIdx; token++, i++) { tMD_FieldDef *pFieldDef; pFieldDef = MetaData.GetFieldDefFromDefOrRef(pMetaData, token, ppClassTypeArgs, ppMethodTypeArgs); if (MetaData.FIELD_ISSTATIC(pFieldDef)) { // Only handle static fields here if (pTypeDef->pGenericDefinition != null) { // If this is a generic instantiation type, then all field defs need to be copied, // as there will be lots of different instantiations. tMD_FieldDef *pFieldCopy = ((tMD_FieldDef *)Mem.mallocForever((SIZE_T)sizeof(tMD_FieldDef))); Mem.memcpy(pFieldCopy, pFieldDef, (SIZE_T)sizeof(tMD_FieldDef)); pFieldDef = pFieldCopy; } if (MetaData.FIELD_ISLITERAL(pFieldDef) || MetaData.FIELD_HASFIELDRVA(pFieldDef)) { // If it's a literal, then analyse the field, but don't include it in any memory allocation // If is has an RVA, then analyse the field, but don't include it in any memory allocation MetaData.Fill_FieldDef(pTypeDef, pFieldDef, 0, null, ppClassTypeArgs); } else { MetaData.Fill_FieldDef(pTypeDef, pFieldDef, staticMemSize, null, ppClassTypeArgs); staticMemSize += pFieldDef->memSize; } pTypeDef->ppFields[i] = pFieldDef; } } if (staticMemSize > 0) { pTypeDef->pStaticFields = (byte *)Mem.mallocForever((SIZE_T)staticMemSize); Mem.memset(pTypeDef->pStaticFields, 0, staticMemSize); // Set the field addresses (->pMemory) of all static fields for (i = 0; i < pTypeDef->numFields; i++) { tMD_FieldDef *pFieldDef; pFieldDef = pTypeDef->ppFields[i]; if (MetaData.FIELD_ISSTATIC(pFieldDef) && pFieldDef->pMemory == null) { // Only set it if it isn't already set. It will be already set if this field has an RVA pFieldDef->pMemory = pTypeDef->pStaticFields + pFieldDef->memOffset; } } pTypeDef->staticFieldSize = staticMemSize; } } if (pTypeDef->fillState >= resolve) { return; } } // This only needs to be done for non-generic Type.types, or for generic type that are not a definition // I.e. Fully instantiated generic Type.types if (pTypeDef->fillState < Type.TYPE_FILL_VTABLE) { pTypeDef->fillState = Type.TYPE_FILL_VTABLE; if (pParent != null) { if (pParent->fillState < Type.TYPE_FILL_VTABLE) { MetaData.Fill_TypeDef(pParent, null, null, Type.TYPE_FILL_VTABLE); } else if (pParent->fillState < Type.TYPE_FILL_ALL) { MetaData.Fill_Defer(pParent, null, null); } } if (pTypeDef->isGenericDefinition == 0) { virtualOfs = (pParent != null) ? pParent->numVirtualMethods : 0; // Must create the virtual method table BEFORE any other type resolution is done // Note that this must not do ANY filling of type or methods. // This is to ensure that the parent object(s) in any type inheritance hierachy are allocated // their virtual method offset before derived Type.types. firstIdx = pTypeDef->methodList; lastIdx = firstIdx + pTypeDef->numMethods - 1; for (token = firstIdx; token <= lastIdx; token++) { tMD_MethodDef *pMethodDef; pMethodDef = MetaData.GetMethodDefFromDefRefOrSpec(pMetaData, token, ppClassTypeArgs, ppMethodTypeArgs); //Sys.printf("Method: %s\n", (PTR)pMethodDef->name); // This is needed, so array resolution can work correctly and FindVirtualOverriddenMethod() can work. pMethodDef->pParentType = pTypeDef; if (MetaData.METHOD_ISVIRTUAL(pMethodDef)) { if (MetaData.METHOD_ISNEWSLOT(pMethodDef) || pTypeDef->pParent == null) { // Allocate a new vTable slot if method is explicitly marked as NewSlot, or // this is of type Object. pMethodDef->vTableOfs = virtualOfs++; } else { tMD_MethodDef *pVirtualOveriddenMethod; pVirtualOveriddenMethod = FindVirtualOverriddenMethod(pTypeDef->pParent, pMethodDef); if (pVirtualOveriddenMethod == null) { Sys.Crash("Unable to find virtual override method for %s %s", (PTR)pTypeDef->name, (PTR)pMethodDef->name); } pMethodDef->vTableOfs = pVirtualOveriddenMethod->vTableOfs; } } else { // Dummy value - make it obvious it's not valid! pMethodDef->vTableOfs = 0xffffffff; } } // Create the virtual method table pTypeDef->numVirtualMethods = virtualOfs; // Resolve all members firstIdx = pTypeDef->methodList; lastIdx = firstIdx + pTypeDef->numMethods - 1; pTypeDef->ppMethods = (tMD_MethodDef **)Mem.mallocForever((SIZE_T)(pTypeDef->numMethods * sizeof(tMD_MethodDef *))); pTypeDef->pVTable = (tMD_MethodDef **)Mem.mallocForever((SIZE_T)(pTypeDef->numVirtualMethods * sizeof(tMD_MethodDef *))); // Copy initial vTable from parent if (pTypeDef->pParent != null) { if (pTypeDef->pParent->fillState != Type.TYPE_FILL_MEMBERS) { Fill_TypeDef(pTypeDef->pParent, null, null, Type.TYPE_FILL_MEMBERS); } Mem.memcpy(pTypeDef->pVTable, pTypeDef->pParent->pVTable, (SIZE_T)(pTypeDef->pParent->numVirtualMethods * sizeof(tMD_MethodDef *))); } for (token = firstIdx, i = 0; token <= lastIdx; token++, i++) { tMD_MethodDef *pMethodDef; pMethodDef = MetaData.GetMethodDefFromDefRefOrSpec(pMetaData, token, ppClassTypeArgs, ppMethodTypeArgs); if (pTypeDef->pGenericDefinition != null) { // If this is a generic instantiation type, then all method defs need to be copied, // as there will be lots of different instantiations. tMD_MethodDef *pMethodCopy = ((tMD_MethodDef *)Mem.mallocForever((SIZE_T)sizeof(tMD_MethodDef))); Mem.memcpy(pMethodCopy, pMethodDef, (SIZE_T)sizeof(tMD_MethodDef)); pMethodDef = pMethodCopy; } if (MetaData.METHOD_ISSTATIC(pMethodDef) && S.strcmp(pMethodDef->name, ".cctor") == 0) { // This is a static constructor pTypeDef->pStaticConstructor = pMethodDef; } if (!MetaData.METHOD_ISSTATIC(pMethodDef) && pTypeDef->pParent != null && S.strcmp(pMethodDef->name, "Finalize") == 0) { // This is a Finalizer method, but not for Object. // Delibrately miss out Object's Finalizer because it's empty and will cause every object // of any type to have a Finalizer which will be terrible for performance. pTypeDef->pFinalizer = pMethodDef; } if (MetaData.METHOD_ISVIRTUAL(pMethodDef)) { // This is a virtual method, so enter it in the vTable pTypeDef->pVTable[pMethodDef->vTableOfs] = pMethodDef; } pTypeDef->ppMethods[i] = pMethodDef; } // Find inherited Finalizer, if this type doesn't have an explicit Finalizer, and if there is one if (pTypeDef->pFinalizer == null) { tMD_TypeDef *pInheritedType = pTypeDef->pParent; while (pInheritedType != null) { if (pInheritedType->pFinalizer != null) { pTypeDef->pFinalizer = pInheritedType->pFinalizer; break; } pInheritedType = pInheritedType->pParent; } } } if (pTypeDef->fillState >= resolve) { return; } } if (pTypeDef->fillState < Type.TYPE_FILL_MEMBERS) { pTypeDef->fillState = Type.TYPE_FILL_MEMBERS; if (pParent != null) { if (pParent->fillState < Type.TYPE_FILL_MEMBERS) { MetaData.Fill_TypeDef(pParent, null, null, Type.TYPE_FILL_MEMBERS); } else if (pParent->fillState < Type.TYPE_FILL_ALL) { MetaData.Fill_Defer(pParent, null, null); } } if (pTypeDef->isGenericDefinition == 0) { // Fill all method definitions for this type for (i = 0; i < pTypeDef->numMethods; i++) { MetaData.Fill_MethodDef(pTypeDef, pTypeDef->ppMethods[i], ppClassTypeArgs, ppMethodTypeArgs); } } if (pTypeDef->fillState >= resolve) { return; } } if (pTypeDef->fillState < Type.TYPE_FILL_INTERFACES) { pTypeDef->fillState = Type.TYPE_FILL_INTERFACES; if (pParent != null) { if (pParent->fillState < Type.TYPE_FILL_INTERFACES) { MetaData.Fill_TypeDef(pParent, null, null, Type.TYPE_FILL_INTERFACES); } else if (pParent->fillState < Type.TYPE_FILL_ALL) { MetaData.Fill_Defer(pParent, null, null); } } if (pTypeDef->isGenericDefinition == 0 && !MetaData.TYPE_ISINTERFACE(pTypeDef)) { if (pParent != null && pParent->fillState < Type.TYPE_FILL_INTERFACES) { MetaData.Fill_TypeDef(pParent, null, null, Type.TYPE_FILL_INTERFACES); } // Map all interface method calls. This only needs to be done for Classes, not Interfaces // And is not done for generic definitions. firstIdx = 0; if (pTypeDef->pParent != null) { j = pTypeDef->numInterfaces = pTypeDef->pParent->numInterfaces; } else { j = 0; } lastIdx = firstIdx; for (i = 1; i <= pMetaData->tables.numRows[MetaDataTable.MD_TABLE_INTERFACEIMPL]; i++) { tMD_InterfaceImpl *pInterfaceImpl; pInterfaceImpl = (tMD_InterfaceImpl *)MetaData.GetTableRow(pMetaData, MetaData.MAKE_TABLE_INDEX(MetaDataTable.MD_TABLE_INTERFACEIMPL, i)); if (pInterfaceImpl->class_ == pTypeDef->tableIndex) { // count how many interfaces are implemented pTypeDef->numInterfaces++; if (firstIdx == 0) { firstIdx = MetaData.MAKE_TABLE_INDEX(MetaDataTable.MD_TABLE_INTERFACEIMPL, i); } lastIdx = MetaData.MAKE_TABLE_INDEX(MetaDataTable.MD_TABLE_INTERFACEIMPL, i); } } if (pTypeDef->numInterfaces > 0) { uint mapNum; pTypeDef->pInterfaceMaps = (tInterfaceMap *)Mem.mallocForever((SIZE_T)(pTypeDef->numInterfaces * sizeof(tInterfaceMap))); // Copy interface maps from parent type if (j > 0) { Mem.memcpy(pTypeDef->pInterfaceMaps, pTypeDef->pParent->pInterfaceMaps, (SIZE_T)(j * sizeof(tInterfaceMap))); } mapNum = j; if (firstIdx > 0) { for (token = firstIdx; token <= lastIdx; token++, mapNum++) { tMD_InterfaceImpl *pInterfaceImpl; pInterfaceImpl = (tMD_InterfaceImpl *)MetaData.GetTableRow(pMetaData, token); if (pInterfaceImpl->class_ == pTypeDef->tableIndex) { tMD_TypeDef * pInterface; tInterfaceMap *pMap; // Get the interface that this type implements pInterface = MetaData.GetTypeDefFromDefRefOrSpec(pMetaData, pInterfaceImpl->interface_, ppClassTypeArgs, ppMethodTypeArgs); MetaData.Fill_TypeDef(pInterface, null, null, Type.TYPE_FILL_INTERFACES); pMap = &pTypeDef->pInterfaceMaps[mapNum]; pMap->pInterface = pInterface; pMap->pVTableLookup = (uint *)Mem.mallocForever((SIZE_T)(pInterface->numVirtualMethods * sizeof(uint))); pMap->ppMethodVLookup = (tMD_MethodDef **)Mem.mallocForever((SIZE_T)(pInterface->numVirtualMethods * sizeof(tMD_MethodDef *))); // Discover interface mapping for each interface method for (i = 0; i < pInterface->numVirtualMethods; i++) { tMD_MethodDef *pInterfaceMethod; tMD_MethodDef *pOverriddenMethod; pInterfaceMethod = pInterface->pVTable[i]; pOverriddenMethod = FindVirtualOverriddenMethod(pTypeDef, pInterfaceMethod); pMap->pVTableLookup[i] = pOverriddenMethod->vTableOfs; pMap->ppMethodVLookup[i] = pOverriddenMethod; } } else { Sys.Crash("Problem with interface class"); } } } } } if (pTypeDef->fillState >= resolve) { return; } } if (pTypeDef->fillState < Type.TYPE_FILL_ALL) { pTypeDef->fillState = Type.TYPE_FILL_ALL; if (pTypeDef->isGenericDefinition == 0 && pTypeDef->stackSize == 0) { j = 0; } if (pParent != null && pParent->fillState < Type.TYPE_FILL_ALL) { MetaData.Fill_TypeDef(pParent, null, null, Type.TYPE_FILL_ALL); } if (isDeferred != 0) { Fill_ResolveDeferred(); } } Sys.log_f(2, "Type: %s.%s\n", (PTR)pTypeDef->nameSpace, (PTR)pTypeDef->name); }
private static tCLIFile *LoadPEFile(byte[] image) { tCLIFile *pRet = ((tCLIFile *)Mem.malloc((SIZE_T)sizeof(tCLIFile))); System.Runtime.InteropServices.GCHandle handle = System.Runtime.InteropServices.GCHandle.Alloc(image, GCHandleType.Pinned); byte *pData = (byte *)handle.AddrOfPinnedObject(); byte *pMSDOSHeader = (byte *)&(((byte *)pData)[0]); byte *pPEHeader; byte *pPEOptionalHeader; byte *pPESectionHeaders; byte *pCLIHeader; byte *pRawMetaData; int i; uint lfanew; ushort machine; int numSections; //uint imageBase; //int fileAlignment; uint cliHeaderRVA; //uint cliHeaderSize; uint metaDataRVA; //uint metaDataSize; tMetaData *pMetaData; pRet->pRVA = RVA.New(); pRet->gcHandle = (PTR)(System.IntPtr)handle; pRet->pMetaData = pMetaData = MetaData.New(); lfanew = *(uint *)&(pMSDOSHeader[0x3c]); pPEHeader = pMSDOSHeader + lfanew + 4; pPEOptionalHeader = pPEHeader + 20; pPESectionHeaders = pPEOptionalHeader + 224; machine = *(ushort *)&(pPEHeader[0]); if (machine != DOT_NET_MACHINE) { return(null); } numSections = *(ushort *)&(pPEHeader[2]); //imageBase = *(uint*)&(pPEOptionalHeader[28]); //fileAlignment = *(int*)&(pPEOptionalHeader[36]); for (i = 0; i < numSections; i++) { byte *pSection = pPESectionHeaders + i * 40; RVA.Create(pRet->pRVA, pData, pSection); } cliHeaderRVA = *(uint *)&(pPEOptionalHeader[208]); //cliHeaderSize = *(uint*)&(pPEOptionalHeader[212]); pCLIHeader = (byte *)RVA.FindData(pRet->pRVA, cliHeaderRVA); metaDataRVA = *(uint *)&(pCLIHeader[8]); //metaDataSize = *(uint*)&(pCLIHeader[12]); pRet->entryPoint = *(uint *)&(pCLIHeader[20]); pRawMetaData = (byte *)RVA.FindData(pRet->pRVA, metaDataRVA); // Load all metadata { uint versionLen = *(uint *)&(pRawMetaData[12]); uint ofs, numberOfStreams; void *pTableStream = null; uint tableStreamSize = 0; pRet->pVersion = &(pRawMetaData[16]); Sys.log_f(1, "CLI version: %s\n", (PTR)pRet->pVersion); ofs = 16 + versionLen; numberOfStreams = *(ushort *)&(pRawMetaData[ofs + 2]); ofs += 4; for (i = 0; i < (int)numberOfStreams; i++) { uint streamOffset = *(uint *)&pRawMetaData[ofs]; uint streamSize = *(uint *)&pRawMetaData[ofs + 4]; byte *pStreamName = &pRawMetaData[ofs + 8]; void *pStream = pRawMetaData + streamOffset; ofs += (uint)((S.strlen(pStreamName) + 4) & (~0x3)) + 8; if (S.strcasecmp(pStreamName, "#Strings") == 0) { MetaData.LoadStrings(pMetaData, pStream, streamSize); } else if (S.strcasecmp(pStreamName, "#US") == 0) { MetaData.LoadUserStrings(pMetaData, pStream, streamSize); } else if (S.strcasecmp(pStreamName, "#Blob") == 0) { MetaData.LoadBlobs(pMetaData, pStream, streamSize); } else if (S.strcasecmp(pStreamName, "#GUID") == 0) { MetaData.LoadGUIDs(pMetaData, pStream, streamSize); } else if (S.strcasecmp(pStreamName, "#~") == 0) { pTableStream = pStream; tableStreamSize = streamSize; } } // Must load tables last if (pTableStream != null) { MetaData.LoadTables(pMetaData, pRet->pRVA, pTableStream, (uint)tableStreamSize); } } // Mark all generic definition type and methods as such for (i = (int)pMetaData->tables.numRows[MetaDataTable.MD_TABLE_GENERICPARAM]; i > 0; i--) { tMD_GenericParam * pGenericParam; /*IDX_TABLE*/ uint ownerIdx; pGenericParam = (tMD_GenericParam *)MetaData.GetTableRow (pMetaData, MetaData.MAKE_TABLE_INDEX(MetaDataTable.MD_TABLE_GENERICPARAM, (uint)i)); ownerIdx = pGenericParam->owner; switch (MetaData.TABLE_ID(ownerIdx)) { case MetaDataTable.MD_TABLE_TYPEDEF: { tMD_TypeDef *pTypeDef = (tMD_TypeDef *)MetaData.GetTableRow(pMetaData, ownerIdx); pTypeDef->isGenericDefinition = 1; } break; case MetaDataTable.MD_TABLE_METHODDEF: { tMD_MethodDef *pMethodDef = (tMD_MethodDef *)MetaData.GetTableRow(pMetaData, ownerIdx); pMethodDef->isGenericDefinition = 1; } break; default: Sys.Crash("Wrong generic parameter owner: 0x%08x", ownerIdx); break; } } // Mark all nested classes as such for (i = (int)pMetaData->tables.numRows[MetaDataTable.MD_TABLE_NESTEDCLASS]; i > 0; i--) { tMD_NestedClass *pNested; tMD_TypeDef * pParent; tMD_TypeDef * pChild; pNested = (tMD_NestedClass *)MetaData.GetTableRow(pMetaData, MetaData.MAKE_TABLE_INDEX(MetaDataTable.MD_TABLE_NESTEDCLASS, (uint)i)); pParent = (tMD_TypeDef *)MetaData.GetTableRow(pMetaData, pNested->enclosingClass); pChild = (tMD_TypeDef *)MetaData.GetTableRow(pMetaData, pNested->nestedClass); pChild->pNestedIn = pParent; } return(pRet); }
public static tMD_MethodDef *GetMethodDefFromCoreMethod(tMD_MethodDef *pCoreMethod, tMD_TypeDef *pParentType, uint numTypeArgs, tMD_TypeDef **ppTypeArgs, HashSet <PTR> resolveTypes = null) { tGenericMethodInstance *pInst; tMD_MethodDef * pMethod; Mem.heapcheck(); // See if we already have an instance with the given type args pInst = pCoreMethod->pGenericMethodInstances; while (pInst != null) { if (pInst->numTypeArgs == numTypeArgs && Mem.memcmp(pInst->ppTypeArgs, ppTypeArgs, (SIZE_T)(numTypeArgs * sizeof(tMD_TypeDef *))) == 0) { return(pInst->pInstanceMethodDef); } pInst = pInst->pNext; } // We don't have an instance so create one now. pInst = (tGenericMethodInstance *)Mem.mallocForever((SIZE_T)(sizeof(tGenericMethodInstance))); pInst->pNext = pCoreMethod->pGenericMethodInstances; pCoreMethod->pGenericMethodInstances = pInst; pInst->numTypeArgs = numTypeArgs; pInst->ppTypeArgs = (tMD_TypeDef **)Mem.malloc((SIZE_T)(numTypeArgs * sizeof(tMD_TypeDef *))); Mem.memcpy(pInst->ppTypeArgs, ppTypeArgs, (SIZE_T)(numTypeArgs * sizeof(tMD_TypeDef *))); pInst->pInstanceMethodDef = pMethod = ((tMD_MethodDef *)Mem.mallocForever((SIZE_T)sizeof(tMD_MethodDef))); Mem.memset(pMethod, 0, (SIZE_T)sizeof(tMD_MethodDef)); pMethod->pMethodDef = pMethod; pMethod->pMetaData = pCoreMethod->pMetaData; pMethod->pCIL = pCoreMethod->pCIL; pMethod->implFlags = pCoreMethod->implFlags; pMethod->flags = pCoreMethod->flags; pMethod->name = pCoreMethod->name; pMethod->signature = pCoreMethod->signature; pMethod->vTableOfs = pCoreMethod->vTableOfs; pMethod->ppMethodTypeArgs = pInst->ppTypeArgs; if (pCoreMethod->monoMethodInfo != null) { System.Reflection.MethodInfo methodInfo = H.ToObj(pCoreMethod->monoMethodInfo) as System.Reflection.MethodInfo; System.Type[] typeArgs = new System.Type[(int)numTypeArgs]; for (uint i = 0; i < numTypeArgs; i++) { typeArgs[i] = MonoType.GetMonoTypeForType(ppTypeArgs[i]); if (typeArgs[i] == null) { Sys.Crash("Unable to find mono type for type arg %s.%s in for generic method %s", (PTR)ppTypeArgs[i]->nameSpace, (PTR)ppTypeArgs[i]->name, (PTR)pCoreMethod->name); } } System.Reflection.MethodInfo genericMethodInfo = methodInfo.MakeGenericMethod(typeArgs); MonoType.Fill_MethodDef(pParentType, genericMethodInfo, pMethod, pParentType->ppClassTypeArgs, pInst->ppTypeArgs); } else { MetaData.Fill_MethodDef(pParentType, pMethod, pParentType->ppClassTypeArgs, pInst->ppTypeArgs); } Mem.heapcheck(); return(pMethod); }
public static tMetaData *GetMetaDataForAssembly(byte *pAssemblyName) { tFilesLoaded *pFiles; int monoAssembly = 0; tCLIFile * pCLIFile = null; tMD_Assembly *pThisAssembly = null; tMetaData ** ppChildMetaData = null; int i, j, childCount; // Check corlib assemblies i = 0; while (dnaCorlibAssemblies[i] != null) { if (S.strcmp(pAssemblyName, dnaCorlibAssemblies[i]) == 0) { pAssemblyName = scCorLib; break; } i++; } // Look in already-loaded files first pFiles = pFilesLoaded; while (pFiles != null) { pCLIFile = pFiles->pCLIFile; if (S.strcmp(pAssemblyName, pCLIFile->assemblyName) == 0) { // Found the correct assembly, so return its meta-data return(pCLIFile->pMetaData); } pFiles = pFiles->pNext; } // Mono/Unity assemblies only load metadata, no code if (monoAssemblies != null) { i = 0; while (monoAssemblies[i] != null) { if (S.strcmp(pAssemblyName, monoAssemblies[i]) == 0) { if (i == 0) { // Handle "UnityEngine" assemblies j = 0; childCount = 0; while (unityModuleAssemblies[j] != null) { childCount++; j++; } ppChildMetaData = (tMetaData **)Mem.malloc((SIZE_T)((childCount + 1) * sizeof(tMetaData *))); Mem.memset(ppChildMetaData, 0, (SIZE_T)((childCount + 1) * sizeof(tMetaData *))); j = 0; while (unityModuleAssemblies[j] != null) { ppChildMetaData[j] = GetMetaDataForAssembly(unityModuleAssemblies[j]); j++; } } monoAssembly = 1; break; } i++; } } // Assembly not loaded, so load it if possible if (monoAssembly != 0) { pCLIFile = CLIFile.WrapMonoAssembly(pAssemblyName); if (pCLIFile == null) { Sys.Crash("Cannot load required mono assembly file: %s.dll", (PTR)pAssemblyName); } } else { byte *fileName = stackalloc byte[256]; S.snprintf(fileName, 256, "%s.dll", (PTR)pAssemblyName); pCLIFile = CLIFile.LoadAssembly(fileName); if (pCLIFile == null) { Sys.Crash("Cannot load required assembly file: %s.dll", (PTR)pAssemblyName); } } pCLIFile->pMetaData->ppChildMetaData = ppChildMetaData; return(pCLIFile->pMetaData); }