public void Int64Load32Unsigned_Compiled_Then_Shift()
{
// Adapted from Int64Load8Unsigned_Compiled_Then_Shift.
const int off = 4;
const byte b = 0x9f;
const int shift = 40;
var compiled = MemoryReadTestBase <long> .CreateInstance(
new LocalGet(),
new Int64Load32Unsigned
{
Offset = off,
},
new Int64Constant(shift),
new Int64ShiftLeft(),
new End()
);
using (compiled)
{
Assert.IsNotNull(compiled);
Assert.IsNotNull(compiled.Exports);
var memory = compiled.Exports.Memory;
Assert.AreNotEqual(IntPtr.Zero, memory.Start);
var exports = compiled.Exports;
Marshal.WriteByte(memory.Start + off, b);
const long should_be = ((long)b) << shift;
Assert.AreEqual(should_be, exports.Test(0));
}
}
public void Float32Load_Compiled_Offset1()
{
var compiled = MemoryReadTestBase <float> .CreateInstance(
new GetLocal(),
new Float32Load
{
Offset = 1,
},
new End()
);
using (compiled)
{
Assert.IsNotNull(compiled);
var exports = compiled.Exports;
Assert.IsNotNull(exports);
var memory = exports.Memory;
Assert.AreNotEqual(IntPtr.Zero, memory.Start);
Assert.AreEqual(0, exports.Test(0));
var invariantCulture = CultureInfo.InvariantCulture;
var testData = Samples.Memory;
Marshal.Copy(testData, 0, memory.Start, testData.Length);
Assert.AreEqual("6.207163E-36", exports.Test(0).ToString(invariantCulture));
Assert.AreEqual("2.501747E-35", exports.Test(1).ToString(invariantCulture));
Assert.AreEqual("1.008251E-34", exports.Test(2).ToString(invariantCulture));
Assert.AreEqual("4.063216E-34", exports.Test(3).ToString(invariantCulture));
Assert.AreEqual("0.03320982", exports.Test(4).ToString(invariantCulture));
Assert.AreEqual("-8.313687E+14", exports.Test(5).ToString(invariantCulture));
Assert.AreEqual("9.602914E-14", exports.Test(6).ToString(invariantCulture));
Assert.AreEqual("-1.912281E+17", exports.Test(7).ToString(invariantCulture));
Assert.AreEqual("2.021882E-38", exports.Test(8).ToString(invariantCulture));
Assert.AreEqual(0, exports.Test((int)Memory.PageSize - 5));
MemoryAccessOutOfRangeException x;
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 4));
Assert.AreEqual(Memory.PageSize - 3, x.Offset);
Assert.AreEqual(4u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 3));
Assert.AreEqual(Memory.PageSize - 2, x.Offset);
Assert.AreEqual(4u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 2));
Assert.AreEqual(Memory.PageSize - 1, x.Offset);
Assert.AreEqual(4u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 1));
Assert.AreEqual(Memory.PageSize, x.Offset);
Assert.AreEqual(4u, x.Length);
ExceptionAssert.Expect <OverflowException>(() => exports.Test(unchecked ((int)uint.MaxValue)));
}
}
public void Float64Load_Compiled_Offset1()
{
var compiled = MemoryReadTestBase <double> .CreateInstance(
new GetLocal(),
new Float64Load
{
Offset = 1,
},
new End()
);
using (compiled)
{
Assert.IsNotNull(compiled);
Assert.IsNotNull(compiled.Exports);
var memory = compiled.Exports.Memory;
Assert.AreNotEqual(IntPtr.Zero, memory.Start);
var exports = compiled.Exports;
Assert.AreEqual(0, exports.Test(0));
var invariantCulture = CultureInfo.InvariantCulture;
var testData = Samples.Memory;
Marshal.Copy(testData, 0, memory.Start, testData.Length);
Assert.AreEqual("1.06703248910785E-14", exports.Test(0).ToString(invariantCulture));
Assert.AreEqual("-1.14389371511465E+117", exports.Test(1).ToString(invariantCulture));
Assert.AreEqual("4.12824598825351E-107", exports.Test(2).ToString(invariantCulture));
Assert.AreEqual("-9.39245758009613E+135", exports.Test(3).ToString(invariantCulture));
Assert.AreEqual("1.60424369241791E-304", exports.Test(4).ToString(invariantCulture));
Assert.AreEqual("1.19599597184682E-309", exports.Test(5).ToString(invariantCulture));
Assert.AreEqual("4.6718592650265E-312", exports.Test(6).ToString(invariantCulture));
Assert.AreEqual("1.82494502538554E-314", exports.Test(7).ToString(invariantCulture));
Assert.AreEqual("7.12869138768568E-317", exports.Test(8).ToString(invariantCulture));
Assert.AreEqual(0, exports.Test((int)Memory.PageSize - 9));
MemoryAccessOutOfRangeException x;
x = Assert.ThrowsException <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 8));
Assert.AreEqual(Memory.PageSize - 7, x.Offset);
Assert.AreEqual(8u, x.Length);
x = Assert.ThrowsException <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 6));
Assert.AreEqual(Memory.PageSize - 5, x.Offset);
Assert.AreEqual(8u, x.Length);
x = Assert.ThrowsException <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 2));
Assert.AreEqual(Memory.PageSize - 1, x.Offset);
Assert.AreEqual(8u, x.Length);
x = Assert.ThrowsException <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 1));
Assert.AreEqual(Memory.PageSize, x.Offset);
Assert.AreEqual(8u, x.Length);
Assert.ThrowsException <OverflowException>(() => exports.Test(unchecked ((int)uint.MaxValue)));
}
}
public void Int64Load_Compiled_Offset1()
{
var compiled = MemoryReadTestBase <long> .CreateInstance(
new LocalGet(),
new Int64Load
{
Offset = 1,
},
new End()
);
using (compiled)
{
Assert.IsNotNull(compiled);
Assert.IsNotNull(compiled.Exports);
var memory = compiled.Exports.Memory;
Assert.AreNotEqual(IntPtr.Zero, memory.Start);
var exports = compiled.Exports;
Assert.AreEqual(0, exports.Test(0));
var testData = Samples.Memory;
Marshal.Copy(testData, 0, memory.Start, testData.Length);
Assert.AreEqual(4397772758562636546, exports.Test(0));
Assert.AreEqual(-2865124961678982141, exports.Test(1));
Assert.AreEqual(3015227055211414788, exports.Test(2));
Assert.AreEqual(-2582295154680986107, exports.Test(3));
Assert.AreEqual(61970503589955334, exports.Test(4));
Assert.AreEqual(242072279648263, exports.Test(5));
Assert.AreEqual(945594842376, exports.Test(6));
Assert.AreEqual(3693729853, exports.Test(7));
Assert.AreEqual(14428632, exports.Test(8));
Assert.AreEqual(0, exports.Test((int)Memory.PageSize - 9));
MemoryAccessOutOfRangeException x;
x = Assert.ThrowsException <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 8));
Assert.AreEqual(Memory.PageSize - 7, x.Offset);
Assert.AreEqual(8u, x.Length);
x = Assert.ThrowsException <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 6));
Assert.AreEqual(Memory.PageSize - 5, x.Offset);
Assert.AreEqual(8u, x.Length);
x = Assert.ThrowsException <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 2));
Assert.AreEqual(Memory.PageSize - 1, x.Offset);
Assert.AreEqual(8u, x.Length);
x = Assert.ThrowsException <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 1));
Assert.AreEqual(Memory.PageSize, x.Offset);
Assert.AreEqual(8u, x.Length);
Assert.ThrowsException <OverflowException>(() => exports.Test(unchecked ((int)uint.MaxValue)));
}
}
public void Int64Load32Signed_Compiled_Offset1()
{
var compiled = MemoryReadTestBase <long> .CreateInstance(
new LocalGet(),
new Int64Load32Signed
{
Offset = 1,
},
new End()
);
using (compiled)
{
Assert.IsNotNull(compiled);
Assert.IsNotNull(compiled.Exports);
var memory = compiled.Exports.Memory;
Assert.AreNotEqual(IntPtr.Zero, memory.Start);
var exports = compiled.Exports;
Assert.AreEqual(0, exports.Test(0));
var testData = Samples.Memory;
Marshal.Copy(testData, 0, memory.Start, testData.Length);
Assert.AreEqual(84148994, exports.Test(0));
Assert.AreEqual(100992003, exports.Test(1));
Assert.AreEqual(117835012, exports.Test(2));
Assert.AreEqual(134678021, exports.Test(3));
Assert.AreEqual(1023936262, exports.Test(4));
Assert.AreEqual(-667088889, exports.Test(5));
Assert.AreEqual(702037256, exports.Test(6));
Assert.AreEqual(-601237443, exports.Test(7));
Assert.AreEqual(14428632, exports.Test(8));
Assert.AreEqual(0, exports.Test((int)Memory.PageSize - 5));
MemoryAccessOutOfRangeException x;
x = Assert.ThrowsException <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 4));
Assert.AreEqual(Memory.PageSize - 3, x.Offset);
Assert.AreEqual(4u, x.Length);
x = Assert.ThrowsException <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 3));
Assert.AreEqual(Memory.PageSize - 2, x.Offset);
Assert.AreEqual(4u, x.Length);
x = Assert.ThrowsException <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 2));
Assert.AreEqual(Memory.PageSize - 1, x.Offset);
Assert.AreEqual(4u, x.Length);
x = Assert.ThrowsException <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 1));
Assert.AreEqual(Memory.PageSize, x.Offset);
Assert.AreEqual(4u, x.Length);
Assert.ThrowsException <OverflowException>(() => exports.Test(unchecked ((int)uint.MaxValue)));
}
}
public void Int64Load32Unsigned_Compiled_Offset0()
{
var compiled = MemoryReadTestBase <long> .CreateInstance(
new GetLocal(),
new Int64Load32Unsigned(),
new End()
);
using (compiled)
{
Assert.IsNotNull(compiled);
Assert.IsNotNull(compiled.Exports);
var memory = compiled.Exports.Memory;
Assert.AreNotEqual(IntPtr.Zero, memory.Start);
var exports = compiled.Exports;
Assert.AreEqual(0, exports.Test(0));
var testData = Samples.Memory;
Marshal.Copy(testData, 0, memory.Start, testData.Length);
Assert.AreEqual(67306238, exports.Test(0));
Assert.AreEqual(84148994, exports.Test(1));
Assert.AreEqual(100992003, exports.Test(2));
Assert.AreEqual(117835012, exports.Test(3));
Assert.AreEqual(134678021, exports.Test(4));
Assert.AreEqual(1023936262, exports.Test(5));
Assert.AreEqual(3627878407, exports.Test(6));
Assert.AreEqual(702037256, exports.Test(7));
Assert.AreEqual(3693729853, exports.Test(8));
Assert.AreEqual(0, exports.Test((int)Memory.PageSize - 4));
MemoryAccessOutOfRangeException x;
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 3));
Assert.AreEqual(Memory.PageSize - 3, x.Offset);
Assert.AreEqual(4u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 2));
Assert.AreEqual(Memory.PageSize - 2, x.Offset);
Assert.AreEqual(4u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 1));
Assert.AreEqual(Memory.PageSize - 1, x.Offset);
Assert.AreEqual(4u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize));
Assert.AreEqual(Memory.PageSize, x.Offset);
Assert.AreEqual(4u, x.Length);
ExceptionAssert.Expect <OverflowException>(() => exports.Test(unchecked ((int)uint.MaxValue)));
}
}
public void Int64Load8Unsigned_Compiled_Then_Shift()
{
if (!Environment.Is64BitProcess)
{
Assert.Inconclusive("32-bit .NET doesn't support 64-bit bit shift amounts.");
}
// seems like the offset here needs to be different so it
// doesn't interfere with other tests above. so I just
// picked a number.
const int off = 4;
const byte b = 0x9f;
// shift needs to be >23 to repro the problem
const int shift = 40;
// the issue here is that Ldind_U8 results in int32,
// not int64. so if the shift would push things too
// far, it gives the wrong result.
// Int64Load8Unsigned will need to do a Conv_I8
// in fact, I believe this affects Int64LoadFoo, for
// all Foo narrow than 64 bits
var compiled = MemoryReadTestBase <long> .CreateInstance(
new LocalGet(),
new Int64Load8Unsigned
{
Offset = off,
},
new Int64Constant(shift),
new Int64ShiftLeft(),
new End()
);
using (compiled)
{
Assert.IsNotNull(compiled);
Assert.IsNotNull(compiled.Exports);
var memory = compiled.Exports.Memory;
Assert.AreNotEqual(IntPtr.Zero, memory.Start);
var exports = compiled.Exports;
Marshal.WriteByte(memory.Start + off, b);
var should_be = ((long)b) << shift;
Assert.AreEqual(should_be, exports.Test(0));
}
}
public void Int32Load16Unsigned_Compiled_Offset1()
{
var compiled = MemoryReadTestBase <int> .CreateInstance(
new GetLocal(),
new Int32Load16Unsigned
{
Offset = 1,
},
new End()
);
using (compiled)
{
Assert.IsNotNull(compiled);
Assert.IsNotNull(compiled.Exports);
var memory = compiled.Exports.Memory;
Assert.AreNotEqual(IntPtr.Zero, memory.Start);
var exports = compiled.Exports;
Assert.AreEqual(0, exports.Test(0));
var testData = Samples.Memory;
Marshal.Copy(testData, 0, memory.Start, testData.Length);
Assert.AreEqual(770, exports.Test(0));
Assert.AreEqual(1027, exports.Test(1));
Assert.AreEqual(1284, exports.Test(2));
Assert.AreEqual(1541, exports.Test(3));
Assert.AreEqual(1798, exports.Test(4));
Assert.AreEqual(2055, exports.Test(5));
Assert.AreEqual(15624, exports.Test(6));
Assert.AreEqual(55357, exports.Test(7));
Assert.AreEqual(10712, exports.Test(8));
Assert.AreEqual(0, exports.Test((int)Memory.PageSize - 3));
MemoryAccessOutOfRangeException x;
x = Assert.ThrowsException <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 2));
Assert.AreEqual(Memory.PageSize - 1, x.Offset);
Assert.AreEqual(2u, x.Length);
x = Assert.ThrowsException <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 1));
Assert.AreEqual(Memory.PageSize, x.Offset);
Assert.AreEqual(2u, x.Length);
Assert.ThrowsException <OverflowException>(() => exports.Test(unchecked ((int)uint.MaxValue)));
}
}
public void Int64Load8Unsigned_Compiled_Offset1()
{
var compiled = MemoryReadTestBase <long> .CreateInstance(
new GetLocal(),
new Int64Load8Unsigned
{
Offset = 1,
},
new End()
);
using (compiled)
{
Assert.IsNotNull(compiled);
Assert.IsNotNull(compiled.Exports);
var memory = compiled.Exports.Memory;
Assert.AreNotEqual(IntPtr.Zero, memory.Start);
var exports = compiled.Exports;
Assert.AreEqual(0, exports.Test(0));
var testData = Samples.Memory;
Marshal.Copy(testData, 0, memory.Start, testData.Length);
Assert.AreEqual(2, exports.Test(0));
Assert.AreEqual(3, exports.Test(1));
Assert.AreEqual(4, exports.Test(2));
Assert.AreEqual(5, exports.Test(3));
Assert.AreEqual(6, exports.Test(4));
Assert.AreEqual(7, exports.Test(5));
Assert.AreEqual(8, exports.Test(6));
Assert.AreEqual(61, exports.Test(7));
Assert.AreEqual(216, exports.Test(8));
Assert.AreEqual(0, exports.Test((int)Memory.PageSize - 5));
MemoryAccessOutOfRangeException x;
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 1));
Assert.AreEqual(Memory.PageSize, x.Offset);
Assert.AreEqual(1u, x.Length);
ExceptionAssert.Expect <OverflowException>(() => exports.Test(unchecked ((int)uint.MaxValue)));
}
}
public void Int64Load32Signed_Compiled_Then_Shift()
{
if (!Environment.Is64BitProcess)
{
Assert.Inconclusive("32-bit .NET doesn't support 64-bit bit shift amounts.");
}
// Adapted from Int64Load8Unsigned_Compiled_Then_Shift.
const int off = 4;
const sbyte b = 0x5f;
const int shift = 40;
var compiled = MemoryReadTestBase <long> .CreateInstance(
new LocalGet(),
new Int64Load32Signed
{
Offset = off,
},
new Int64Constant(shift),
new Int64ShiftLeft(),
new End()
);
using (compiled)
{
Assert.IsNotNull(compiled);
Assert.IsNotNull(compiled.Exports);
var memory = compiled.Exports.Memory;
Assert.AreNotEqual(IntPtr.Zero, memory.Start);
var exports = compiled.Exports;
Marshal.WriteByte(memory.Start + off, (byte)b);
const long should_be = ((long)b) << shift;
Assert.AreEqual(should_be, exports.Test(0));
}
}
