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 unsafe static bool IsNegativeZero(ref double d)
{
//Make a pointer to the pointer, which when dereferenced can access the result.
System.IntPtr value = Unsafe.AddressOf(ref d);
//Check for -0.0
return((*((long *)((int *)&value))).Equals(Common.Binary.NegativeZeroBits));
}
public TypedInformation(T t)
: base(new Classes.T.T()
{
Reference = Unsafe.AddressOf(ref t)
})
{
TypeReference = new TypeReference <T>(t);
}
public static ArrayObject **GetArrayObject <T>(ref T t) where T : class
{
if (!typeof(T).IsArray)
{
TypeException.Throw <Array, T>();
}
return((ArrayObject **)Unsafe.AddressOf(ref t));
}
/// <summary>
/// Manually reads a CLR MethodTable (TypeHandle)
/// </summary>
/// <returns>A pointer to the object type's MethodTable</returns>
public static MethodTable *ReadMethodTable <T>(ref T t)
{
// Value types do not have a MethodTable ptr, but they do have a TypeHandle.
if (typeof(T).IsValueType)
{
return(MethodTableOf <T>());
}
// We need to get the heap pointer manually because of type constraints
var ptr = (Marshal.ReadIntPtr(Unsafe.AddressOf(ref t)));
var @out = *(MethodTable **)ptr;
return(@out);
//return (*((HeapObject**) Unsafe.AddressOf(ref t)))->MethodTable;
}
/// <summary>
/// Asserts that a Pointer points to the correct object address during GC pressure
/// </summary>
internal static void AssertPressure <TPointer, TValue>(Pointer <TPointer> ptr, ref TValue t)
{
int passes = 0;
while (passes++ < MaxPasses)
{
object[] oArr = new object[MaxObjects];
for (int i = 0; i < oArr.Length; i++)
{
oArr[i] = new object();
}
Assert.That(ptr.Value, Is.EqualTo(t));
Assert.That(ptr.Address, Is.EqualTo(Unsafe.AddressOf(ref t)));
}
}
/// <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 unsafe bool Equals(Extensions other)
{
return(object.ReferenceEquals(this, NilExtensions) ? object.ReferenceEquals(other, NilExtensions) : Unsafe.AddressOf(this) == Unsafe.AddressOf(other));
}
//fixme
private EEClassLayoutInfo *GetLayoutInfo()
{
return(&((LayoutEEClass *)(Unsafe.AddressOf(ref this)))->m_LayoutInfo); //
}
public static HeapObject **GetHeapObject <T>(ref T t) where T : class
{
HeapObject **h = (HeapObject **)Unsafe.AddressOf(ref t);
return(h);
}
public static StringObject **GetStringObject(ref string s)
{
return((StringObject **)Unsafe.AddressOf(ref s));
}
/// <summary>
/// <c>PTR_HOST_MEMBER_TADDR</c>
/// </summary>
internal static Pointer <byte> HostMemberOffset <T>(ref T value, long ofs, Pointer <byte> fieldValue)
where T : struct
{
return(Unsafe.AddressOf(ref value).Add((long)fieldValue).Add(ofs).Cast());
}
protected internal AddressInfo(ref T t)
{
Address = Unsafe.AddressOf(ref t);
}