using System;
using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Runtime.CompilerServices;
/*
* Regression tests for the mono JIT.
public long d;
}
+struct Small {
+ public byte b1;
+ public byte b2;
+}
+
+struct Large {
+ int one;
+ int two;
+ long three;
+ long four;
+ int five;
+ long six;
+ int seven;
+ long eight;
+ long nine;
+ long ten;
+
+ public void populate ()
+ {
+ one = 1; two = 2;
+ three = 3; four = 4;
+ five = 5; six = 6;
+ seven = 7; eight = 8;
+ nine = 9; ten = 10;
+ }
+ public bool check ()
+ {
+ return one == 1 && two == 2 &&
+ three == 3 && four == 4 &&
+ five == 5 && six == 6 &&
+ seven == 7 && eight == 8 &&
+ nine == 9 && ten == 10;
+ }
+}
+
class Sample {
public int a;
public Sample (int v) {
}
}
+[StructLayout ( LayoutKind.Explicit )]
+struct StructWithBigOffsets {
+ [ FieldOffset(10000) ] public byte b;
+ [ FieldOffset(10001) ] public sbyte sb;
+ [ FieldOffset(11000) ] public short s;
+ [ FieldOffset(11002) ] public ushort us;
+ [ FieldOffset(12000) ] public uint i;
+ [ FieldOffset(12004) ] public int si;
+ [ FieldOffset(13000) ] public long l;
+ [ FieldOffset(14000) ] public float f;
+ [ FieldOffset(15000) ] public double d;
+}
+
enum SampleEnum {
A,
B,
return 5;
}
+ // Test alignment of small structs
+
+ static Small get_small (byte v) {
+ Small r = new Small ();
+
+ r.b1 = v;
+ r.b2 = (byte)(v + 1);
+
+ return r;
+ }
+
+ static Small return_small (Small s) {
+ return s;
+ }
+
+ static int receive_small (int a, Small v, int b) {
+ if (v.b1 != 1)
+ return 1;
+ if (v.b2 != 2)
+ return 2;
+ return 0;
+ }
+
+ static int test_5_pass_small_struct () {
+ Small v = get_small (1);
+ if (receive_small (7, v, 9) != 0)
+ return 0;
+ if (receive_small (7, get_small (1), 9) != 0)
+ return 1;
+ v = return_small (v);
+ if (v.b1 != 1)
+ return 2;
+ if (v.b2 != 2)
+ return 3;
+ return 5;
+ }
+
+ struct AStruct {
+ public int i;
+
+ public AStruct (int i) {
+ this.i = i;
+ }
+
+ public override int GetHashCode () {
+ return i;
+ }
+ }
+
+ // Test that vtypes are unboxed during a virtual call
+ static int test_44_unbox_trampoline () {
+ AStruct s = new AStruct (44);
+ object o = s;
+ return o.GetHashCode ();
+ }
+
+ static int test_0_unbox_trampoline2 () {
+ int i = 12;
+ object o = i;
+
+ if (i.ToString () != "12")
+ return 1;
+ if (((Int32)o).ToString () != "12")
+ return 2;
+ if (o.ToString () != "12")
+ return 3;
+ return 0;
+ }
+
+ // Test fields with big offsets
+ static int test_0_fields_with_big_offsets () {
+ StructWithBigOffsets s = new StructWithBigOffsets ();
+ StructWithBigOffsets s2 = new StructWithBigOffsets ();
+
+ s.b = 0xde;
+ s.sb = 0xe;
+ s.s = 0x12de;
+ s.us = 0x12da;
+ s.i = 0xdeadbeef;
+ s.si = 0xcafe;
+ s.l = 0xcafebabe;
+ s.f = 3.14F;
+ s.d = 3.14;
+
+ s2.b = s.b;
+ s2.sb = s.sb;
+ s2.s = s.s;
+ s2.us = s.us;
+ s2.i = s.i;
+ s2.si = s.si;
+ s2.l = s.l;
+ s2.f = s.f;
+ s2.d = s.d;
+
+ if (s2.b != 0xde)
+ return 1;
+ if (s2.s != 0x12de)
+ return 2;
+ if (s2.i != 0xdeadbeef)
+ return 3;
+ if (s2.l != 0xcafebabe)
+ return 4;
+ if (s2.f != 3.14F)
+ return 5;
+ if (s2.d != 3.14)
+ return 6;
+ if (s2.sb != 0xe)
+ return 7;
+ if (s2.us != 0x12da)
+ return 9;
+ if (s2.si != 0xcafe)
+ return 10;
+
+ return 0;
+ }
+
class TestRegA {
long buf_start;
int buf_length, buf_offset;
+
+ public TestRegA () {
+ buf_start = 0;
+ buf_length = 0;
+ buf_offset = 0;
+ }
public long Seek (long position) {
long pos = position;
}
class Duper: Super {
}
+
+ static int test_0_null_cast () {
+ object o = null;
+
+ Super s = (Super)o;
+
+ return 0;
+ }
static int test_0_super_cast () {
Duper d = new Duper ();
return 1;
return 2;
}
+
+ static int llmult (int a, int b, int c, int d) {
+ return a + b + c + d;
+ }
+
+ /*
+ * Test that evaluation of complex arguments does not overwrite the
+ * arguments already in outgoing registers.
+ */
+ static int test_155_regalloc () {
+ int a = 10;
+ int b = 10;
+
+ int c = 0;
+ int d = 0;
+ int[] arr = new int [5];
+
+ return llmult (arr [c + d], 150, 5, 0);
+ }
+
+ static bool large_struct_test (Large a, Large b, Large c, Large d)
+ {
+ if (!a.check ()) return false;
+ if (!b.check ()) return false;
+ if (!c.check ()) return false;
+ if (!d.check ()) return false;
+ return true;
+ }
+
+ static int test_2_large_struct_pass ()
+ {
+ Large a, b, c, d;
+ a = new Large ();
+ b = new Large ();
+ c = new Large ();
+ d = new Large ();
+ a.populate ();
+ b.populate ();
+ c.populate ();
+ d.populate ();
+ if (large_struct_test (a, b, c, d))
+ return 2;
+ return 0;
+ }
+
+ public static unsafe int test_0_pin_string () {
+ string x = "xxx";
+ fixed (char *c = x) {
+ if (*c != 'x')
+ return 1;
+ }
+ return 0;
+ }
+
+ public static int my_flags;
+ public static int test_0_and_cmp_static ()
+ {
+
+ /* various forms of test [mem], imm */
+
+ my_flags = 0x01020304;
+
+ if ((my_flags & 0x01020304) == 0)
+ return 1;
+
+ if ((my_flags & 0x00000304) == 0)
+ return 2;
+
+ if ((my_flags & 0x00000004) == 0)
+ return 3;
+
+ if ((my_flags & 0x00000300) == 0)
+ return 4;
+
+ if ((my_flags & 0x00020000) == 0)
+ return 5;
+
+ if ((my_flags & 0x01000000) == 0)
+ return 6;
+
+ return 0;
+ }
+
+ static byte b;
+ public static int test_0_byte_compares ()
+ {
+ b = 0xff;
+ if (b == -1)
+ return 1;
+ b = 0;
+ if (!(b < System.Byte.MaxValue))
+ return 2;
+
+ if (!(b <= System.Byte.MaxValue))
+ return 3;
+
+ return 0;
+ }
+
+ public static int test_71_long_shift_right () {
+ ulong value = 38654838087;
+ int x = 0;
+ byte [] buffer = new byte [1];
+ buffer [x] = ((byte)(value >> x));
+ return buffer [x];
+ }
+
+ static long x;
+ public static int test_0_addsub_mem ()
+ {
+ x = 0;
+ x += 5;
+
+ if (x != 5)
+ return 1;
+
+ x -= 10;
+
+ if (x != -5)
+ return 2;
+
+ return 0;
+ }
+
+ static ulong y;
+ public static int test_0_sh32_mem ()
+ {
+ y = 0x0102130405060708;
+ y >>= 32;
+
+ if (y != 0x01021304)
+ return 1;
+
+ y = 0x0102130405060708;
+ y <<= 32;
+
+ if (y != 0x0506070800000000)
+ return 2;
+
+ x = 0x0102130405060708;
+ x <<= 32;
+
+ if (x != 0x0506070800000000)
+ return 2;
+
+ return 0;
+ }
+
+
+ static uint dum_de_dum = 1;
+ static int test_0_long_arg_opt ()
+ {
+ return Foo (0x1234567887654321, dum_de_dum);
+ }
+
+ static int Foo (ulong x, ulong y)
+ {
+ if (x != 0x1234567887654321)
+ return 1;
+
+ if (y != 1)
+ return 2;
+
+ return 0;
+ }
+
+ static int test_0_long_ret_opt ()
+ {
+ ulong x = X ();
+ if (x != 0x1234567887654321)
+ return 1;
+ ulong y = Y ();
+ if (y != 1)
+ return 2;
+
+ return 0;
+ }
+
+ static ulong X ()
+ {
+ return 0x1234567887654321;
+ }
+
+ static ulong Y ()
+ {
+ return dum_de_dum;
+ }
+
+ /* from bug# 71515 */
+ static int counter = 0;
+ static bool WriteStuff () {
+ counter = 10;
+ return true;
+ }
+ static int test_0_cond_branch_side_effects () {
+ counter = 5;
+ if (WriteStuff());
+ if (counter == 10)
+ return 0;
+ return 1;
+ }
+
+ // bug #74992
+ public static int arg_only_written (string file_name, int[]
+ncells ) {
+ if (file_name == null)
+ return 1;
+
+ ncells = foo ();
+ bar (ncells [0]);
+
+ return 0;
+ }
+
+ public static int[] foo () {
+ return new int [3];
+ }
+
+ public static void bar (int i) {
+ }
+
+
+ public static int test_0_arg_only_written ()
+ {
+ return arg_only_written ("md.in", null);
+ }
+
+ static long position = 0;
+
+ public static int test_4_static_inc_long () {
+
+ int count = 4;
+
+ position = 0;
+
+ position += count;
+
+ return (int)position;
+ }
+
+ struct FooStruct {
+
+ public FooStruct (long l) {
+ }
+ }
+
+ static int test_0_calls_opcode_emulation () {
+ // Test that emulated opcodes do not clobber arguments already in
+ // out registers
+ checked {
+ long val = 10000;
+ new FooStruct (val * 10000);
+ }
+ return 0;
+ }
+
+ static int test_0_intrins_string_length () {
+ string s = "ABC";
+
+ return (s.Length == 3) ? 0 : 1;
+ }
+
+ static int test_0_intrins_string_chars () {
+ string s = "ABC";
+
+ return (s [0] == 'A' && s [1] == 'B' && s [2] == 'C') ? 0 : 1;
+ }
+
+ static int test_0_intrins_object_gettype () {
+ object o = 1;
+
+ return (o.GetType () == typeof (int)) ? 0 : 1;
+ }
+
+ static int test_0_intrins_object_gethashcode () {
+ object o = new Object ();
+
+ return (o.GetHashCode () == o.GetHashCode ()) ? 0 : 1;
+ }
+
+ class FooClass {
+ }
+
+ static int test_0_intrins_object_ctor () {
+ object o = new FooClass ();
+
+ return (o != null) ? 0 : 1;
+ }
+
+ static int test_0_intrins_array_rank () {
+ int[,] a = new int [10, 10];
+
+ return (a.Rank == 2) ? 0 : 1;
+ }
+
+ static int test_0_intrins_array_length () {
+ int[,] a = new int [10, 10];
+ Array a2 = a;
+
+ return (a2.Length == 100) ? 0 : 1;
+ }
+
+ static int test_0_intrins_runtimehelpers_offset_to_string_data () {
+ int i = RuntimeHelpers.OffsetToStringData;
+
+ return i - i;
+ }
}
projects / mono.git / blobdiff