You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
183 lines
5.7 KiB
183 lines
5.7 KiB
|
|
using UnityBenchShared; |
|
|
|
namespace Burst.Compiler.IL.Tests |
|
{ |
|
internal class TestFixed |
|
{ |
|
public unsafe struct SomeStruct |
|
{ |
|
public static readonly int[] Ints = new int[4] { 1, 2, 3, 4 }; |
|
|
|
public struct OtherStruct |
|
{ |
|
public int x; |
|
} |
|
|
|
public static readonly OtherStruct[] Structs = new OtherStruct[2] { new OtherStruct { x = 42 }, new OtherStruct { x = 13 } }; |
|
|
|
public fixed ushort array[42]; |
|
|
|
public struct Provider : IArgumentProvider |
|
{ |
|
public object Value |
|
{ |
|
get |
|
{ |
|
var s = new SomeStruct(); |
|
|
|
for (ushort i = 0; i < 42; i++) |
|
{ |
|
s.array[i] = i; |
|
} |
|
|
|
return s; |
|
} |
|
} |
|
} |
|
} |
|
|
|
[TestCompiler] |
|
public static unsafe int ReadInts() |
|
{ |
|
fixed (int* ptr = SomeStruct.Ints) |
|
{ |
|
return ptr[2]; |
|
} |
|
} |
|
|
|
[TestCompiler] |
|
public static unsafe int ReadIntsElement() |
|
{ |
|
fixed (int* ptr = &SomeStruct.Ints[1]) |
|
{ |
|
return ptr[0]; |
|
} |
|
} |
|
|
|
[TestCompiler] |
|
public static unsafe int ReadStructs() |
|
{ |
|
fixed (SomeStruct.OtherStruct* ptr = SomeStruct.Structs) |
|
{ |
|
return ptr[1].x; |
|
} |
|
} |
|
|
|
[TestCompiler] |
|
public static unsafe int ReadStructsElement() |
|
{ |
|
fixed (SomeStruct.OtherStruct* ptr = &SomeStruct.Structs[1]) |
|
{ |
|
return ptr[0].x; |
|
} |
|
} |
|
|
|
[TestCompiler(typeof(SomeStruct.Provider))] |
|
public static unsafe ushort ReadFromFixedArray(ref SomeStruct s) |
|
{ |
|
fixed (ushort* ptr = s.array) |
|
{ |
|
ushort total = 0; |
|
|
|
for (ushort i = 0; i < 42; i++) |
|
{ |
|
total += ptr[i]; |
|
} |
|
|
|
return total; |
|
} |
|
} |
|
|
|
// The below tests are designed to verify the indexer is treated correctly for various fixed arrays (only the smallest case) |
|
//(the bug was actually to do with pointer addition, so see 031-Pointer.cs for additional coverage) |
|
//Its not perfect as if the indexer is treated as signed, then in burst we will read off the beginning of the array |
|
//which might be into another array or off the beginning of the struct... and the value might accidently be correct. |
|
public unsafe struct IndexerStructTestSByte |
|
{ |
|
public fixed sbyte sbyteArray[256]; |
|
|
|
public struct Provider : IArgumentProvider |
|
{ |
|
public object Value |
|
{ |
|
get |
|
{ |
|
var s = new IndexerStructTestSByte(); |
|
|
|
for (int a=0;a<256;a++) |
|
{ |
|
s.sbyteArray[a] = sbyte.MinValue; |
|
} |
|
|
|
s.sbyteArray[127] = 127; |
|
s.sbyteArray[128] = 63; |
|
s.sbyteArray[255] = 23; |
|
|
|
return s; |
|
} |
|
} |
|
} |
|
} |
|
public unsafe struct IndexerStructTestByte |
|
{ |
|
public fixed byte byteArray[256]; |
|
|
|
public struct Provider : IArgumentProvider |
|
{ |
|
public object Value |
|
{ |
|
get |
|
{ |
|
var s = new IndexerStructTestByte(); |
|
|
|
for (int a=0;a<256;a++) |
|
{ |
|
s.byteArray[a] = byte.MinValue; |
|
} |
|
|
|
s.byteArray[127] = 129; |
|
s.byteArray[128] = 212; |
|
s.byteArray[255] = 165; |
|
|
|
return s; |
|
} |
|
} |
|
} |
|
} |
|
// SByte array with different indexer types |
|
[TestCompiler(typeof(IndexerStructTestSByte.Provider),(byte)0)] |
|
[TestCompiler(typeof(IndexerStructTestSByte.Provider),(byte)128)] |
|
[TestCompiler(typeof(IndexerStructTestSByte.Provider),(byte)255)] |
|
public static unsafe sbyte IndexerReadFromSByteArrayWithByteOffset(ref IndexerStructTestSByte s, byte offset) |
|
{ |
|
return s.sbyteArray[offset]; |
|
} |
|
|
|
[TestCompiler(typeof(IndexerStructTestSByte.Provider),(sbyte)0)] |
|
[TestCompiler(typeof(IndexerStructTestSByte.Provider),(sbyte)127)] // signed offset so limited |
|
public static unsafe sbyte IndexerReadFromSByteArrayWithSByteOffset(ref IndexerStructTestSByte s, sbyte offset) |
|
{ |
|
return s.sbyteArray[offset]; |
|
} |
|
|
|
// Byte array with different indexer types |
|
[TestCompiler(typeof(IndexerStructTestByte.Provider),(byte)0)] |
|
[TestCompiler(typeof(IndexerStructTestByte.Provider),(byte)128)] |
|
[TestCompiler(typeof(IndexerStructTestByte.Provider),(byte)255)] |
|
public static unsafe byte IndexerReadFromByteArrayWithByteOffset(ref IndexerStructTestByte s, byte offset) |
|
{ |
|
return s.byteArray[offset]; |
|
} |
|
|
|
[TestCompiler(typeof(IndexerStructTestByte.Provider),(sbyte)0)] |
|
[TestCompiler(typeof(IndexerStructTestByte.Provider),(sbyte)127)] // signed offset so limited |
|
public static unsafe byte IndexerReadFromByteArrayWithSByteOffset(ref IndexerStructTestByte s, sbyte offset) |
|
{ |
|
return s.byteArray[offset]; |
|
} |
|
} |
|
|
|
|
|
|
|
}
|
|
|