public void Test()
{
int valType = 0xFF;
Assert.That(new IntPtr(&valType), Is.EqualTo(Unsafe.AddressOf(ref valType)));
string s = "foo";
Assert.That(new IntPtr(CSUnsafe.AsPointer(ref s)), Is.EqualTo(Unsafe.AddressOf(ref s)));
IntPtr sChars = Unsafe.AddressOfHeap(ref s, OffsetType.StringData);
Assert.That(Marshal.ReadInt16(sChars), Is.EqualTo(s[0]));
int[] arr = { 1, 2, 3 };
IntPtr arrData = Unsafe.AddressOfHeap(ref arr, OffsetType.ArrayData);
Assert.That(Marshal.ReadInt32(arrData), Is.EqualTo(arr[0]));
Dummy d = new Dummy(100, "bar");
IntPtr dData = Unsafe.AddressOfHeap(ref d, OffsetType.Fields);
// Largest field is first in memory
Assert.That(Marshal.ReadInt32(dData, IntPtr.Size), Is.EqualTo(100));
}
public static void WriteMethodTable <T>(ref T t, MethodTable *m) where T : class
{
var addrMt = Unsafe.AddressOfHeap(ref t);
*((MethodTable **)addrMt) = m;
//var h = GetHeapObject(ref t);
//(**h).MethodTable = m;
}
internal ReferenceAddressInfo(ref T t) : base(ref t)
{
Heap = Unsafe.AddressOfHeap(ref t);
Fields = Unsafe.AddressOfHeap(ref t, OffsetType.Fields);
if (typeof(T).IsArray)
{
HeapMisc = Unsafe.AddressOfHeap(ref t, OffsetType.ArrayData);
}
else if (typeof(T) == typeof(string))
{
HeapMisc = Unsafe.AddressOfHeap(ref t, OffsetType.StringData);
}
else
{
HeapMisc = IntPtr.Zero;
}
}
/// <summary>
/// Asserts that the heap and stack pointers of a reference type don't change at all
/// during GC compaction. This test will pass if the parameter is pinned.
/// </summary>
internal static void AssertPinning <T>(ref T t) where T : class
{
(IntPtr stackPtr, IntPtr heap)mem = (Unsafe.AddressOf(ref t), Unsafe.AddressOfHeap(ref t));
int passes = 0;
while (passes++ < MaxPasses)
{
object[] oArr = new object[MaxObjects];
for (int i = 0; i < oArr.Length; i++)
{
oArr[i] = new object();
}
// pass when reference is pinned
Assert.That(mem.stackPtr, Is.EqualTo(Unsafe.AddressOf(ref t)));
Assert.That(mem.heap, Is.EqualTo(Unsafe.AddressOfHeap(ref t)));
}
}
public void TestString()
{
string s = "anime";
DecayPointer <char> ptr = s;
Assert.That(ptr.FirstElement, Is.EqualTo(Unsafe.AddressOfHeap(ref s, OffsetType.StringData)));
// Test indexing
for (int i = 0; i < s.Length; i++)
{
Assert.That(ptr[i], Is.EqualTo(s[i]));
}
// Test incrementing
for (int i = 0; i < s.Length; i++, ptr++)
{
Assert.That(ptr.Value, Is.EqualTo(s[i]));
Assert.That(ptr[0], Is.EqualTo(s[i]));
}
// Test decrementing
for (int i = s.Length - 1; i >= 0; i--)
{
Assert.That(ptr.Value, Is.EqualTo(s[i]));
ptr--;
}
Assert.That(ptr.Value, Is.EqualTo(s[0]));
Assert.That(ptr[0], Is.EqualTo(s[0]));
//s += " bar";
Assert.That(ptr.Address, Is.EqualTo(Unsafe.AddressOfHeap(ref s, OffsetType.StringData)));
Assert.That(ptr.Count, Is.EqualTo(s.Length));
//Debug.Assert(ptr.ToArray().SequenceEqual(s));
}
/// <summary>
/// Reads a reference type's object header.
/// </summary>
/// <returns>A pointer to the reference type's header</returns>
public static ObjHeader *ReadObjHeader <T>(ref T t) where T : class
{
IntPtr data = Unsafe.AddressOfHeap(ref t);
return((ObjHeader *)(data - IntPtr.Size));
}
public void Setup()
{
_arrPtr = Unsafe.AddressOfHeap(ref _arr, OffsetType.ArrayData);
}
internal static ObjHeader ReadObjHeader <T>(T value) where T : class
{
var ptr = Unsafe.AddressOfHeap(value, OffsetOptions.HEADER).Cast <ObjHeader>();
return(ptr.Value);
}
