private unsafe static Object NewOperatorHook(IntPtr mt)
{
if (IsNoAlloc)
{
// TODO:
// Temporary whitelist. Need some way to allocate AllocationEntry without new operator.
// @Harnel
if (mt != (IntPtr)MethodTable.GetMethodTable <AllocationEntry>())
{
try
{
IsNoAlloc = false;
Thread curr = Thread.CurrentThread;
throw new MemoryRestrictorException(
$"Tried to allocate in NoAlloc region. Thread: ({curr.Name}, #{curr.ManagedThreadId}), MT: {mt.ToInt64():X}");
}
finally
{
IsNoAlloc = true;
}
}
}
return(NewOperatorHijackContext.Funclet.Invoke(mt));
}
/// <summary>
/// Similar with FormatterServices.GetUninitializedObject. Allocate and return zeroed T-typed object.
/// </summary>
public static ClassDisposeHandle UninitializedAllocation(Type t, out Object result)
{
MethodTable *mt = MethodTable.GetMethodTable(t);
int size = mt->BaseSize;
ObjectHeader *objHeader = (ObjectHeader *)RawMemoryManager.Allocate(size);
objHeader->SyncBlock = 0;
objHeader->MethodTable = mt;
RawMemoryManager.FillMemory(objHeader + 1, 0, size - sizeof(ObjectHeader));
result = TypedReferenceHelper.PointerToObject <Object>(objHeader);
return(new ClassDisposeHandle(size, objHeader));
}
public void StringSize()
{
MethodTable *stringMt = MethodTable.GetMethodTable <String>();
Assert.IsTrue(stringMt->HasComponentSize());
Assert.AreEqual(
sizeof(Char),
stringMt->ComponentSize);
// Temporary disabled until we implement allocation-free string.
//Assert.AreEqual(
// AlignSizeByPointerSize(sizeof(ObjectHeader) + sizeof(Int32)) + sizeof(Char),
// stringMt->BaseSize);
}
public static ClassDisposeHandle Box <T>(T val, out Object boxed) where T : struct
{
MethodTable *mt = MethodTable.GetMethodTable <T>();
int size = mt->BaseSize;
ObjectHeader *objHeader = (ObjectHeader *)RawMemoryManager.Allocate(size);
void *src = TypedReferenceHelper.StructToPointer(ref val);
objHeader->SyncBlock = 0;
objHeader->MethodTable = mt;
RawMemoryManager.MemCpy(objHeader + 1, src, mt->DataSize);
boxed = TypedReferenceHelper.PointerToObject <Object>(objHeader);
return(new ClassDisposeHandle(size, objHeader));
}
public void PrimitiveTypeSize()
{
MethodTable *byteMt = MethodTable.GetMethodTable <Byte>();
Assert.AreEqual(
AlignSizeByPointerSize(sizeof(ObjectHeader) + sizeof(Byte)),
byteMt->BaseSize);
MethodTable *intMt = MethodTable.GetMethodTable <Int32>();
Assert.AreEqual(
AlignSizeByPointerSize(sizeof(ObjectHeader) + sizeof(Int32)),
intMt->BaseSize);
MethodTable *doubleMt = MethodTable.GetMethodTable <Double>();
Assert.AreEqual(
AlignSizeByPointerSize(sizeof(ObjectHeader) + sizeof(Double)),
doubleMt->BaseSize);
}
public static ClassDisposeHandle AllocateSZArray <T>(int size, out T[] array)
{
MethodTable *pElementMT = MethodTable.GetMethodTable <T>();
MethodTable *pArrayMT = MethodTable.GetMethodTable <T[]>();
int elementSize = pElementMT->IsClass ? sizeof(IntPtr) : pElementMT->DataSize;
int memSize = sizeof(ObjectHeader) + sizeof(SZArrayHeader) + elementSize * size;
int align = sizeof(IntPtr) - 1;
memSize = (memSize + align) & (~align);
void * addr = RawMemoryManager.Allocate(memSize);
ObjectHeader * objHeader = (ObjectHeader *)addr;
SZArrayHeader *szArrayHeader = (SZArrayHeader *)(objHeader + 1);
objHeader->MethodTable = pArrayMT;
szArrayHeader->NumComponents = size;
array = TypedReferenceHelper.PointerToObject <T[]>(objHeader);
return(new ClassDisposeHandle(memSize, objHeader));
}
