public static void LoadGUIDs(tMetaData *pThis, void *pStream, uint streamLen)
{
pThis->GUIDs.numGUIDs = streamLen / 16;
// This is stored -16 because numbering starts from 1. This means that a simple indexing calculation
// can be used, as if it started from 0
pThis->GUIDs.pGUID1 = (byte *)pStream;
Sys.log_f(1, "Read %d GUIDs\n", pThis->GUIDs.numGUIDs);
}
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 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);
}
// 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 void LoadUserStrings(tMetaData *pThis, void *pStream, uint streamLen)
{
pThis->userStrings.pStart = (byte *)pStream;
Sys.log_f(1, "Loaded User Strings\n");
}
public static void LoadBlobs(tMetaData *pThis, void *pStream, uint streamLen)
{
pThis->blobs.pStart = (byte *)pStream;
Sys.log_f(1, "Loaded blobs\n");
}
public static uint Update(uint maxInstr, int *pReturnCode)
{
tThread *pThread;
tThread *pPrevThread;
uint status;
pThread = pAllThreads;
// Set the initial thread to the RUNNING state.
pThread->state = THREADSTATE_RUNNING;
// Set the initial CurrentThread
pCurrentThread = pThread;
for (;;)
{
uint minSleepTime = 0xffffffff;
int threadExitValue;
status = JIT_Execute.Execute(pThread, maxInstr);
switch (status)
{
case Thread.THREAD_STATUS_EXIT:
threadExitValue = pThread->threadExitValue;
Sys.log_f(1, "Thread ID#%d exited. Return value: %d\n", (int)pThread->threadID, (int)threadExitValue);
// Remove the current thread from the running threads list.
// Note that this list may have changed since before the call to JitOps.JIT_Execute().
{
if (pAllThreads == pThread)
{
pAllThreads = pAllThreads->pNextThread;
}
else
{
tThread *pThread1 = pAllThreads;
while (pThread1->pNextThread != pThread)
{
pThread1 = pThread1->pNextThread;
}
pThread1->pNextThread = pThread1->pNextThread->pNextThread;
}
}
// Delete the current thread
Thread.Delete(pThread);
// If there are no more threads left running, then exit application (by returning)
// Threads that are unstarted or background do not stop the exit
// [Steve edit] Threads that are suspended also do not stop the exit. This is because you'd just
// wait forever for them if they did. Note that 'exit' doesn't mean tearing down the process
// like in a regular .NET runtime case. The application state is still there and we can make
// further calls into it to create new threads.
{
tThread *pThread2 = pAllThreads;
uint canExit = 1;
while (pThread2 != null)
{
if (
((pThread2->state & THREADSTATE_BACKGROUND) == 0) &&
((pThread2->state & (~THREADSTATE_BACKGROUND)) != THREADSTATE_UNSTARTED) &&
((pThread2->state & (~THREADSTATE_BACKGROUND)) != THREADSTATE_SUSPENDED))
{
canExit = 0;
break;
}
pThread2 = pThread2->pNextThread;
}
if (canExit != 0)
{
if (pReturnCode != null)
{
*pReturnCode = threadExitValue;
}
return(THREADSTATE_STOPPED);
}
}
pThread = pAllThreads; // This is not really correct, but it'll work for the time being
break;
case THREAD_STATUS_RUNNING:
case THREAD_STATUS_LOCK_EXIT:
// Nothing to do
break;
case THREAD_STATUS_ASYNC:
pThread->pAsync->startTime = Sys.msTime();
break;
}
// Move on to the next thread.
// Find the next thread that isn't sleeping or blocked on IO
pPrevThread = pThread;
for (;;)
{
pThread = pThread->pNextThread;
if (pThread == null)
{
// That was the thread -- return!
return(THREADSTATE_RUNNING);
}
// Set the CurrentThread correctly
pCurrentThread = pThread;
if ((pThread->state & (~THREADSTATE_BACKGROUND)) != 0)
{
// Thread is not running
continue;
}
if (pThread->pAsync != null)
{
// Discover if whatever is being waited for is finished
tAsyncCall *pAsync = pThread->pAsync;
if (pAsync->sleepTime >= 0)
{
// This is a sleep
ulong nowTime = Sys.msTime();
int msSleepRemaining = pAsync->sleepTime - (int)(nowTime - pAsync->startTime);
if (msSleepRemaining <= 0)
{
// Sleep is finished
break;
}
// Sleep is not finished, so continue to next thread
if ((uint)msSleepRemaining < minSleepTime)
{
minSleepTime = (uint)msSleepRemaining;
}
}
else
{
// This is blocking IO, or a lock
tMethodState *pMethodState = pThread->pCurrentMethodState;
byte * pThis;
uint thisOfs;
uint unblocked;
if (MetaData.METHOD_ISSTATIC(pMethodState->pMethod))
{
pThis = null;
thisOfs = 0;
}
else
{
pThis = *(byte **)pMethodState->pParamsLocals;
thisOfs = 4;
}
unblocked = ((fnInternalCallCheck)H.ToObj(pAsync->checkFn))(null, pThis, pMethodState->pParamsLocals + thisOfs, pMethodState->pEvalStack, pAsync);
if (unblocked != 0)
{
// The IO has unblocked, and the return value is ready.
// So delete the async object.
// TODO: The async->state object needs to be deleted somehow (maybe)
Mem.free(pAsync);
// And remove it from the thread
pThread->pAsync = null;
break;
}
minSleepTime = 5;
}
}
else
{
// Thread is ready to run
break;
}
if (pThread == pPrevThread)
{
// When it gets here, it means that all threads are currently blocked.
//printf("All blocked; sleep(%d)\n", minSleepTime);
Sys.SleepMS(minSleepTime);
}
}
}
}
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 void GarbageCollect()
{
#if NO
tHeapRoots heapRoots;
tHeapEntry * pNode;
tHeapEntry **pUp = stackalloc tHeapEntry *[MAX_TREE_DEPTH * 2];
int top;
tHeapEntry * pToDelete = null;
SIZE_T orgHeapSize = trackHeapSize;
uint orgNumNodes = numNodes;
#if DIAG_GC
ulong startTime;
#endif
Mem.heapcheck();
numCollections++;
#if DIAG_GC
startTime = microTime();
#endif
heapRoots.capacity = 64;
heapRoots.num = 0;
heapRoots.pHeapEntries = (tHeapRootEntry *)Mem.malloc(heapRoots.capacity * (SIZE_T)sizeof(tHeapRootEntry));
Thread.GetHeapRoots(&heapRoots);
CLIFile.GetHeapRoots(&heapRoots);
// Mark phase
while (heapRoots.num > 0)
{
tHeapRootEntry *pRootsEntry;
uint i;
uint moreRootsAdded = 0;
uint rootsEntryNumPointers;
void ** pRootsEntryMem;
// Get a piece of memory off the list of heap memory roots.
pRootsEntry = &heapRoots.pHeapEntries[heapRoots.num - 1];
rootsEntryNumPointers = pRootsEntry->numPointers;
pRootsEntryMem = pRootsEntry->pMem;
// Mark this entry as done
pRootsEntry->numPointers = 0;
pRootsEntry->pMem = null;
// Iterate through all pointers in it
for (i = 0; i < rootsEntryNumPointers; i++)
{
void *pMemRef = pRootsEntryMem[i];
// Quick escape for known non-memory
if (pMemRef == null)
{
continue;
}
// Find this piece of heap memory in the tracking tree.
// Note that the 2nd memory address comparison MUST be >, not >= as might be expected,
// to allow for a zero-sized memory to be detected (and not garbage collected) properly.
// E.g. The object class has zero memory.
pNode = pHeapTreeRoot;
while (pNode != nil)
{
if (pMemRef < (void *)pNode)
{
pNode = (tHeapEntry *)pNode->pLink[0];
}
else if ((byte *)pMemRef > ((byte *)pNode) + GetSize(pNode) + sizeof(tHeapEntry))
{
pNode = (tHeapEntry *)pNode->pLink[1];
}
else
{
// Found memory. See if it's already been marked.
// If it's already marked, then don't do anything.
// It it's not marked, then add all of its memory to the roots, and mark it.
if (pNode->marked == 0)
{
tMD_TypeDef *pType = pNode->pTypeDef;
// Not yet marked, so mark it, and add it to heap roots.
pNode->marked = 1;
// Don't look at the contents of strings, arrays of primitive Type.types, or WeakReferences
if (pType->stackType == EvalStack.EVALSTACK_O ||
pType->stackType == EvalStack.EVALSTACK_VALUETYPE ||
pType->stackType == EvalStack.EVALSTACK_PTR)
{
if (pType != Type.types[Type.TYPE_SYSTEM_STRING] &&
(!MetaData.TYPE_ISARRAY(pType) ||
pType->pArrayElementType->stackType == EvalStack.EVALSTACK_O ||
pType->pArrayElementType->stackType == EvalStack.EVALSTACK_VALUETYPE ||
pType->pArrayElementType->stackType == EvalStack.EVALSTACK_PTR))
{
if (pType != Type.types[Type.TYPE_SYSTEM_WEAKREFERENCE])
{
Heap.SetRoots(&heapRoots, ((byte *)&pNode->pSync + sizeof(PTR)), GetSize(pNode));
moreRootsAdded = 1;
}
}
}
}
break;
}
}
}
if (moreRootsAdded == 0)
{
heapRoots.num--;
}
}
Mem.free(heapRoots.pHeapEntries);
// Sweep phase
// Traverse nodes
pUp[0] = pHeapTreeRoot;
top = 1;
while (top != 0)
{
// Get this node
pNode = pUp[--top];
// Act on this node
if (pNode->marked != 0)
{
if (pNode->marked != 0xff)
{
// Still in use (but not marked undeletable), so unmark
pNode->marked = 0;
}
}
else
{
// Not in use any more, so put in deletion queue if it does not need Finalizing
// If it does need Finalizing, then don't garbage collect, and put in Finalization queue.
if (pNode->needToFinalize != 0)
{
if (pNode->needToFinalize == 1)
{
Finalizer.AddFinalizer((/*HEAP_PTR*/ byte *)pNode + sizeof(tHeapEntry));
// Mark it has having been placed in the finalization queue.
// When it has been finalized, then this will be set to 0
pNode->needToFinalize = 2;
// If this object is being targetted by weak-ref(s), handle it
if (pNode->pSync != null)
{
RemoveWeakRefTarget(pNode, 0);
Mem.free(pNode->pSync);
}
}
}
else
{
// If this object is being targetted by weak-ref(s), handle it
if (pNode->pSync != null)
{
RemoveWeakRefTarget(pNode, 1);
Mem.free(pNode->pSync);
}
// Use pSync to point to next entry in this linked-list.
pNode->pSync = (tSync *)pToDelete;
pToDelete = pNode;
}
}
// Get next node(s)
if (pNode->pLink[1] != (PTR)nil)
{
pUp[top++] = (tHeapEntry *)pNode->pLink[1];
}
if (pNode->pLink[0] != (PTR)nil)
{
pUp[top++] = (tHeapEntry *)pNode->pLink[0];
}
}
// Delete all unused memory nodes.
while (pToDelete != null)
{
tHeapEntry *pThis = pToDelete;
pToDelete = (tHeapEntry *)(pToDelete->pSync);
pHeapTreeRoot = TreeRemove(pHeapTreeRoot, pThis);
if (pThis->monoHandle == 1)
{
void *hptr = *(void **)((byte *)pThis + sizeof(tHeapEntry));
if (hptr != null)
{
H.Free(hptr);
}
}
numNodes--;
trackHeapSize -= GetSize(pThis) + (uint)sizeof(tHeapEntry);
Mem.free(pThis);
}
Mem.heapcheck();
#if DIAG_GC
gcTotalTime += microTime() - startTime;
#endif
Sys.log_f(1, "--- GARBAGE --- [Size: %d -> %d] [Nodes: %d -> %d]\n",
orgHeapSize, trackHeapSize, orgNumNodes, numNodes);
#if DIAG_GC
Sys.log_f(1, "GC time = %d ms\n", gcTotalTime / 1000);
#endif
#endif
}
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);
}