/* REQUIRED_ARGS: -mcpu=native PERMUTE_ARGS: -O -inline -release */ import core.stdc.stdio; template tuple(A...) { alias tuple = A; } /////////////////////// // https://github.com/dlang/dmd/pull/11441 long sdiv1(long l) { return l / 2; } int sdiv2(int i) { return i / 2; } void testsdiv2() { assert(sdiv1(10) == 5); assert(sdiv1(-10) == -5); assert(sdiv2(10) == 5); assert(sdiv2(-10) == -5); } /////////////////////// void testulldiv() { __gshared ulong[4][] vectors = [ [10,3,3,1], [10,1,10,0], [3,10,0,3], [10,10,1,0], [10_000_000_000L, 11_000_000_000L, 0, 10_000_000_000L], [11_000_000_000L, 10_000_000_000L, 1, 1_000_000_000L], [11_000_000_000L, 11_000_000_000L, 1, 0], [10_000_000_000L, 10, 1_000_000_000L, 0], [0x8000_0000_0000_0000, 0x8000_0000_0000_0000, 1, 0], [0x8000_0000_0000_0001, 0x8000_0000_0000_0001, 1, 0], [0x8000_0001_0000_0000, 0x8000_0001_0000_0000, 1, 0], [0x8000_0001_0000_0000, 0x8000_0000_0000_0000, 1, 0x1_0000_0000], [0x8000_0001_0000_0000, 0x8000_0000_8000_0000, 1, 0x8000_0000], [0x8000_0000_0000_0000, 0x7FFF_FFFF_FFFF_FFFF, 1, 1], [0x8000_0000_0000_0000, 0x8000_0000_0000_0001, 0, 0x8000_0000_0000_0000], [0x8000_0000_0000_0000, 0x8000_0001_0000_0000, 0, 0x8000_0000_0000_0000], ]; for (size_t i = 0; i < vectors.length; i++) { ulong q = vectors[i][0] / vectors[i][1]; if (q != vectors[i][2]) printf("[%zd] %lld / %lld = %lld, should be %lld\n", i, vectors[i][0], vectors[i][1], q, vectors[i][2]); ulong r = vectors[i][0] % vectors[i][1]; if (r != vectors[i][3]) printf("[%zd] %lld %% %lld = %lld, should be %lld\n", i, vectors[i][0], vectors[i][1], r, vectors[i][3]); } } //////////////////////////////////////////////////////////////////////// uint udiv10(uint x) { return x / 10; } uint udiv14(uint x) { return x / 14; } uint udiv14007(uint x) { return x / 14007; } uint umod10(uint x) { return x % 10; } uint umod14(uint x) { return x % 14; } uint umod14007(uint x) { return x % 14007; } uint uremquo10(uint x) { return (x / 10) | (x % 10); } uint uremquo14(uint x) { return (x / 14) | (x % 14); } uint uremquo14007(uint x) { return (x / 14007) | (x % 14007); } ulong uldiv10(ulong x) { return x / 10; } ulong uldiv14(ulong x) { return x / 14; } ulong uldiv14007(ulong x) { return x / 14007; } ulong ulmod10(ulong x) { return x % 10; } ulong ulmod14(ulong x) { return x % 14; } ulong ulmod14007(ulong x) { return x % 14007; } ulong ulremquo10(ulong x) { return (x / 10) | (x % 10); } ulong ulremquo14(ulong x) { return (x / 14) | (x % 14); } ulong ulremquo14007(ulong x) { return (x / 14007) | (x % 14007); } void testfastudiv() { { static uint x10 = 10; static uint x14 = 14; static uint x14007 = 14007; uint u = 10000; uint r; r = udiv10(u); assert(r == u/x10); r = udiv14(u); assert(r == u/x14); r = udiv14007(u); assert(r == u/x14007); r = umod10(u); assert(r == u%x10); r = umod14(u); assert(r == u%x14); r = umod14007(u); assert(r == u%x14007); r = uremquo10(u); assert(r == ((u/10)|(u%x10))); r = uremquo14(u); assert(r == ((u/14)|(u%x14))); r = uremquo14007(u); assert(r == ((u/14007)|(u%x14007))); } { static ulong y10 = 10; static ulong y14 = 14; static ulong y14007 = 14007; ulong u = 10000; ulong r; r = uldiv10(u); assert(r == u/y10); r = uldiv14(u); assert(r == u/y14); r = uldiv14007(u); assert(r == u/y14007); r = ulmod10(u); assert(r == u%y10); r = ulmod14(u); assert(r == u%y14); r = ulmod14007(u); assert(r == u%y14007); r = ulremquo10(u); assert(r == ((u/10)|(u%y10))); r = ulremquo14(u); assert(r == ((u/14)|(u%y14))); r = ulremquo14007(u); assert(r == ((u/14007)|(u%y14007))); } } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=14936 long sldiv1 (long x) { return x / (1L << 1); } long sldiv2 (long x) { return x / (1L << 2); } long sldiv3 (long x) { return x / (1L << 3); } long sldiv7 (long x) { return x / (1L << 7); } long sldiv8 (long x) { return x / (1L << 8); } long sldiv9 (long x) { return x / (1L << 9); } long sldiv30(long x) { return x / (1L << 30); } long sldiv31(long x) { return x / (1L << 31); } long sldiv32(long x) { return x / (1L << 32); } long sldiv33(long x) { return x / (1L << 33); } long sldiv34(long x) { return x / (1L << 34); } long sldiv62(long x) { return x / (1L << 62); } long sldiv63(long x) { return x / (1L << 63); } void testsldiv() { /* Test special div code for signed long divide * by power of 2 for 32 bit targets. */ // printf("63 = %llx\n", sldiv63(-0x7FFF_F8FF_FF3F_2FFFL)); static foreach (C; tuple!( 1,2,3,10,300,1000, 4_1001_2030_0030, 0x7FFF_F8FF_FF3F_2FFFL)) { /* Check if runtime computation matches compile time */ assert(sldiv1 ( C) == C / (1L << 1)); assert(sldiv1 (-C) == -C / (1L << 1)); assert(sldiv2 ( C) == C / (1L << 2)); assert(sldiv2 (-C) == -C / (1L << 2)); assert(sldiv3 ( C) == C / (1L << 3)); assert(sldiv3 (-C) == -C / (1L << 3)); assert(sldiv7 ( C) == C / (1L << 7)); assert(sldiv7 (-C) == -C / (1L << 7)); assert(sldiv8 ( C) == C / (1L << 8)); assert(sldiv8 (-C) == -C / (1L << 8)); assert(sldiv9 ( C) == C / (1L << 9)); assert(sldiv9 (-C) == -C / (1L << 9)); assert(sldiv30( C) == C / (1L << 30)); assert(sldiv30(-C) == -C / (1L << 30)); assert(sldiv31( C) == C / (1L << 31)); assert(sldiv31(-C) == -C / (1L << 31)); assert(sldiv32( C) == C / (1L << 32)); assert(sldiv32(-C) == -C / (1L << 32)); assert(sldiv33( C) == C / (1L << 33)); assert(sldiv33(-C) == -C / (1L << 33)); assert(sldiv34( C) == C / (1L << 34)); assert(sldiv34(-C) == -C / (1L << 34)); assert(sldiv62( C) == C / (1L << 62)); assert(sldiv62(-C) == -C / (1L << 62)); assert(sldiv63( C) == C / (1L << 63)); assert(sldiv63(-C) == -C / (1L << 63)); } } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=14936 long slmod1 (long x) { return x % (1L << 1); } long slmod2 (long x) { return x % (1L << 2); } long slmod3 (long x) { return x % (1L << 3); } long slmod7 (long x) { return x % (1L << 7); } long slmod8 (long x) { return x % (1L << 8); } long slmod9 (long x) { return x % (1L << 9); } long slmod30(long x) { return x % (1L << 30); } long slmod31(long x) { return x % (1L << 31); } long slmod32(long x) { return x % (1L << 32); } long slmod33(long x) { return x % (1L << 33); } long slmod34(long x) { return x % (1L << 34); } long slmod62(long x) { return x % (1L << 62); } long slmod63(long x) { return x % (1L << 63); } void testslmod() { static foreach (C; tuple!( 1,2,3,10,300,1000, 4_1001_2030_0030, 0x7FFF_F8FF_FF3F_2FFFL)) { /* Check if runtime computation matches compile time */ assert(slmod1 ( C) == C % (1L << 1)); assert(slmod1 (-C) == -C % (1L << 1)); assert(slmod2 ( C) == C % (1L << 2)); assert(slmod2 (-C) == -C % (1L << 2)); assert(slmod3 ( C) == C % (1L << 3)); assert(slmod3 (-C) == -C % (1L << 3)); assert(slmod7 ( C) == C % (1L << 7)); assert(slmod7 (-C) == -C % (1L << 7)); assert(slmod8 ( C) == C % (1L << 8)); assert(slmod8 (-C) == -C % (1L << 8)); assert(slmod9 ( C) == C % (1L << 9)); assert(slmod9 (-C) == -C % (1L << 9)); assert(slmod30( C) == C % (1L << 30)); assert(slmod30(-C) == -C % (1L << 30)); assert(slmod31( C) == C % (1L << 31)); assert(slmod31(-C) == -C % (1L << 31)); assert(slmod32( C) == C % (1L << 32)); assert(slmod32(-C) == -C % (1L << 32)); assert(slmod33( C) == C % (1L << 33)); assert(slmod33(-C) == -C % (1L << 33)); assert(slmod34( C) == C % (1L << 34)); assert(slmod34(-C) == -C % (1L << 34)); assert(slmod62( C) == C % (1L << 62)); assert(slmod62(-C) == -C % (1L << 62)); assert(slmod63( C) == C % (1L << 63)); assert(slmod63(-C) == -C % (1L << 63)); } } //////////////////////////////////////////////////////////////////////// T divC(int C, T)(T x) { T y = x; y /= C; assert(y == x / C); y = x; y /= -C; assert(y == x / -C); return x / C; } T modC(int C, T)(T x) { T y = x; y %= C; assert(y == x % C); y = x; y %= -C; assert(y == x % -C); return x % C; } T remquoC(int C, T)(T x) { return (x / C) | (x % C); } void testfastdiv() { static int z = 0; // prevent constant folding by optimizer static foreach (T; tuple!(int, long, uint, ulong)) {{ T u = 10000; T r; static foreach (C; tuple!(10, 14, 14007, -10, -14, -14007)) { r = divC!C(u); assert(r == u / (z + C)); r = modC!C(u); assert(r == u % (z + C)); r = remquoC!C(u); assert(r == ((u / (z + C) | (u % (z + C))))); } }} } //////////////////////////////////////////////////////////////////////// /* Test the pattern: * replace ((i / C1) / C2) with (i / (C1 * C2)) * when e1 is 0 or 1 and (i2-i1) is a power of 2. */ void divdiv(T, T C1, T C2)(T i) { auto a = (i / C1) / C2; auto b = i / (C1 * C2); if (a != b) assert(0); } void testdivdiv() { divdiv!(int,10,20)(30); divdiv!(uint,10,20)(30); divdiv!(long,10,20)(30); divdiv!(ulong,10,20)(30); divdiv!(int,-10,20)(30); divdiv!(long,-10,20)(30); divdiv!(int,-10,-20)(-30); divdiv!(long,-10,-20)(-30); } //////////////////////////////////////////////////////////////////////// void testdivcmp() { // https://github.com/dlang/dmd/pull/7128 static bool foo(uint a, uint b) { return cast(bool)(a / b); // convert / to >= } assert(!foo(3, 4)); assert(foo(4, 4)); assert(foo(5, 4)); } ///////////////////////////////////////////////////// void testgoto() { int i; i = 3; goto L4; L3: i++; goto L5; L4: goto L3; L5: assert(i == 4); } int testswitch() { int i; i = 3; switch (i) { case 0: case 1: default: assert(0); case 3: break; } return 0; } void testdo() { int x = 0; do { x++; } while (x < 10); printf("x == %d\n", x); assert(x == 10); } void testbreak() { int i, j; Louter: for (i = 0; i < 10; i++) { for (j = 0; j < 10; j++) { if (j == 3) break Louter; } } printf("i = %d, j = %d\n", i, j); assert(i == 0); assert(j == 3); } /////////////////////// int foo(string s) { int i; i = 0; switch (s) { case "hello": i = 1; break; case "goodbye": i = 2; break; case "goodb": i = 3; break; default: i = 10; break; } return i; } void teststringswitch() { int i; i = foo("hello"); printf("i = %d\n", i); assert(i == 1); i = foo("goodbye"); printf("i = %d\n", i); assert(i == 2); i = foo("goodb"); printf("i = %d\n", i); assert(i == 3); i = foo("huzzah"); printf("i = %d\n", i); assert(i == 10); } /////////////////////// struct Foo { int a; char b; long c; } Foo test(Foo f) { f.a += 1; f.b += 3; f.c += 4; return f; } void teststrarg() { Foo g; g.a = 1; g.b = 2; g.c = 3; Foo q; q = test(g); assert(q.a == 2); assert(q.b == 5); assert(q.c == 7); } /////////////////////// align (1) struct Foo1 { align (1): int a; char b; long c; } struct Foo2 { int a; char b; long c; } struct Foo3 { int a; align (1) char b; long c; } struct Foo4 { int a; struct { char b; } long c; } void testsizes() { printf("%zd\n", Foo1.sizeof); assert(Foo1.a.offsetof == 0); assert(Foo1.b.offsetof == 4); assert(Foo1.c.offsetof == 5); assert(Foo1.sizeof == 13); assert(Foo2.a.offsetof == 0); assert(Foo2.b.offsetof == 4); assert(Foo2.c.offsetof == 8); assert(Foo2.sizeof == 16); assert(Foo3.a.offsetof == 0); assert(Foo3.b.offsetof == 4); assert(Foo3.c.offsetof == 8); assert(Foo3.b.sizeof == 1); assert(Foo3.sizeof == 16); assert(Foo4.sizeof == 16); } /////////////////////// size_t cond11565(size_t val) { return val ? size_t.max : 0; } void test11565() { assert(cond11565(true) == size_t.max); } // https://issues.dlang.org/show_bug.cgi?id=23743 void test23743() { ubyte[] a = [1]; foreach (x; a) { ubyte v = x >= 1 ? 255 : 0; assert(v == 255); } } /////////////////////// int[3] array1 = [1:1,2,0:3]; void testarrayinit() { assert(array1[0] == 3); assert(array1[1] == 1); assert(array1[2] == 2); } /////////////////////// void test13023(ulong n) { static void func(bool b) {} ulong k = 0; func(k >= n / 2); if (k >= n / 2) assert(0); } /////////////////////// struct U { int a; union { char c; int d; } long b; } U f = { b:3, d:0x22222222, a:1 }; void testU() { assert(f.b == 3); assert(f.d == 0x22222222); assert(f.c == 0x22); assert(f.a == 1); assert(f.sizeof == 16); assert(U.sizeof == 16); } //////////////////////////////////////////////////////////////////////// void vfunc() {} void test12095(int k) { int e = 0; e ? k || assert(0) : !e || vfunc(); e ? k || assert(0) : e && vfunc(); !e ? !e || vfunc() : k || assert(0); } //////////////////////////////////////////////////////////////////////// bool test3918a( float t, real u ) { printf("%Lf\n", u ); return t && u; } bool test3918b( real t, float u ) { printf("%Lf\n", t ); return t && u; } void test3918() { assert(test3918a(float.nan, real.nan)); assert(test3918b(real.nan, float.nan)); } //////////////////////////////////////////////////////////////////////// T docond1(T)(T l, ubyte thresh, ubyte val) { l += (thresh < val); return l; } T docond2(T)(T l, ubyte thresh, ubyte val) { l -= (thresh >= val); return l; } T docond3(T)(T l, ubyte thresh, ubyte val) { l += (thresh >= val); return l; } T docond4(T)(T l, ubyte thresh, ubyte val) { l -= (thresh < val); return l; } void testdocond() { assert(docond1!ubyte(10,3,5) == 11); assert(docond1!ushort(10,3,5) == 11); assert(docond1!uint(10,3,5) == 11); assert(docond1!ulong(10,3,5) == 11); assert(docond2!ubyte(10,3,5) == 10); assert(docond2!ushort(10,3,5) == 10); assert(docond2!uint(10,3,5) == 10); assert(docond2!ulong(10,3,5) == 10); assert(docond3!ubyte(10,3,5) == 10); assert(docond3!ushort(10,3,5) == 10); assert(docond3!uint(10,3,5) == 10); assert(docond3!ulong(10,3,5) == 10); assert(docond4!ubyte(10,3,5) == 9); assert(docond4!ushort(10,3,5) == 9); assert(docond4!uint(10,3,5) == 9); assert(docond4!ulong(10,3,5) == 9); assert(docond1!ubyte(10,5,3) == 10); assert(docond1!ushort(10,5,3) == 10); assert(docond1!uint(10,5,3) == 10); assert(docond1!ulong(10,5,3) == 10); assert(docond2!ubyte(10,5,3) == 9); assert(docond2!ushort(10,5,3) == 9); assert(docond2!uint(10,5,3) == 9); assert(docond2!ulong(10,5,3) == 9); assert(docond3!ubyte(10,5,3) == 11); assert(docond3!ushort(10,5,3) == 11); assert(docond3!uint(10,5,3) == 11); assert(docond3!ulong(10,5,3) == 11); assert(docond4!ubyte(10,5,3) == 10); assert(docond4!ushort(10,5,3) == 10); assert(docond4!uint(10,5,3) == 10); assert(docond4!ulong(10,5,3) == 10); } //////////////////////////////////////////////////////////////////////// struct S8658 { int[16385] a; } void foo8658(S8658 s) { int x; } void test8658() { S8658 s; for(int i = 0; i < 1000; i++) foo8658(s); } //////////////////////////////////////////////////////////////////////// uint neg(uint i) { return ~i + 1; } uint com(uint i) { return -i - 1; } float com(float i) { return -i - 1; } uint com2(uint i) { return -(i + 1); } void testnegcom() { assert(neg(3) == -3); assert(com(3) == -4); assert(com(3.0f) == -4.0f); assert(com2(3) == -4); } //////////////////////////////////////////////////////////////////////// int oror1(char c) { return ((((((((((cast(int) c <= 32 || cast(int) c == 46) || cast(int) c == 44) || cast(int) c == 58) || cast(int) c == 59) || cast(int) c == 60) || cast(int) c == 62) || cast(int) c == 34) || cast(int) c == 92) || cast(int) c == 39) != 0); } int oror2(char c) { return ((((((((((c <= 32 || c == 46) || c == 44) || c == 58) || c == 59) || c == 60) || c == 62) || c == 34) || c == 92) || c == 39) != 0); } void testoror() { assert(oror1(0) == 1); assert(oror1(32) == 1); assert(oror1(46) == 1); assert(oror1(44) == 1); assert(oror1(58) == 1); assert(oror1(59) == 1); assert(oror1(60) == 1); assert(oror1(62) == 1); assert(oror1(34) == 1); assert(oror1(92) == 1); assert(oror1(39) == 1); assert(oror1(33) == 0); assert(oror1(61) == 0); assert(oror1(93) == 0); assert(oror1(255) == 0); assert(oror2(0) == 1); assert(oror2(32) == 1); assert(oror2(46) == 1); assert(oror2(44) == 1); assert(oror2(58) == 1); assert(oror2(59) == 1); assert(oror2(60) == 1); assert(oror2(62) == 1); assert(oror2(34) == 1); assert(oror2(92) == 1); assert(oror2(39) == 1); assert(oror2(33) == 0); assert(oror2(61) == 0); assert(oror2(93) == 0); assert(oror2(255) == 0); } //////////////////////////////////////////////////////////////////////// bool bt1(int p, int a, int b) { return p && ((1 << b) & a); } bool bt2(int p, long a, long b) { return p && ((1L << b) & a); } void testbt() { assert(bt1(1,7,2) == 1); assert(bt1(1,7,3) == 0); assert(bt2(1,0x7_0000_0000,2+32) == 1); assert(bt2(1,0x7_0000_0000,3+32) == 0); } //////////////////////////////////////////////////////////////////////// void test13383() { foreach (k; 32..33) { if (1L & (1L << k)) { assert(0); } } } //////////////////////////////////////////////////////////////////////// int andand1(int c) { return (c > 32 && c != 46 && c != 44 && c != 58 && c != 59 && c != 60 && c != 62 && c != 34 && c != 92 && c != 39) != 0; } bool andand2(long c) { return (c > 32 && c != 46 && c != 44 && c != 58 && c != 59 && c != 60 && c != 62 && c != 34 && c != 92 && c != 39) != 0; } int foox3() { return 1; } int andand3(uint op) { if (foox3() && op != 7 && op != 3 && op != 18 && op != 30 && foox3()) return 3; return 4; } void testandand() { assert(andand1(0) == 0); assert(andand1(32) == 0); assert(andand1(46) == 0); assert(andand1(44) == 0); assert(andand1(58) == 0); assert(andand1(59) == 0); assert(andand1(60) == 0); assert(andand1(62) == 0); assert(andand1(34) == 0); assert(andand1(92) == 0); assert(andand1(39) == 0); assert(andand1(33) == 1); assert(andand1(61) == 1); assert(andand1(93) == 1); assert(andand1(255) == 1); assert(andand2(0) == false); assert(andand2(32) == false); assert(andand2(46) == false); assert(andand2(44) == false); assert(andand2(58) == false); assert(andand2(59) == false); assert(andand2(60) == false); assert(andand2(62) == false); assert(andand2(34) == false); assert(andand2(92) == false); assert(andand2(39) == false); assert(andand2(33) == true); assert(andand2(61) == true); assert(andand2(93) == true); assert(andand2(255) == true); assert(andand3(6) == 3); assert(andand3(30) == 4); } //////////////////////////////////////////////////////////////////////// bool bittest11508(char c) { return c=='_' || c=='-' || c=='+' || c=='.'; } void testbittest() { assert(bittest11508('_')); } //////////////////////////////////////////////////////////////////////// uint or1(ubyte x) { return x | (x<<8) | (x<<16) | (x<<24) | (x * 3); } void testor_combine() { printf("%x\n", or1(1)); assert(or1(5) == 5 * (0x1010101 | 3)); } //////////////////////////////////////////////////////////////////////// int shrshl(int i) { return ((i+1)>>1)<<1; } void testshrshl() { assert(shrshl(6) == 6); assert(shrshl(7) == 8); } //////////////////////////////////////////////////////////////////////// bool bt10715(in uint[] ary, size_t bitnum) { return !!(ary[bitnum >> 5] & 1 << (bitnum & 31)); // uses bt } bool neg_bt10715(in uint[] ary, size_t bitnum) { return !(ary[bitnum >> 5] & 1 << (bitnum & 31)); // does not use bt } void test10715() { static uint[2] a1 = [0x1001_1100, 0x0220_0012]; if ( bt10715(a1,30)) assert(0); if (!bt10715(a1,8)) assert(0); if ( bt10715(a1,30+32)) assert(0); if (!bt10715(a1,1+32)) assert(0); if (!neg_bt10715(a1,30)) assert(0); if ( neg_bt10715(a1,8)) assert(0); if (!neg_bt10715(a1,30+32)) assert(0); if ( neg_bt10715(a1,1+32)) assert(0); } //////////////////////////////////////////////////////////////////////// ptrdiff_t compare12164(A12164* rhsPA, A12164* zis) { if (*rhsPA == *zis) return 0; return ptrdiff_t.min; } struct A12164 { int a; } void test12164() { auto a = A12164(3); auto b = A12164(2); assert(compare12164(&a, &b)); } //////////////////////////////////////////////////////////////////////// int foo10678(char[5] txt) { return txt[0] + txt[1] + txt[4]; } void test10678() { char[5] hello = void; hello[0] = 8; hello[1] = 9; hello[4] = 10; int i = foo10678(hello); assert(i == 27); } //////////////////////////////////////////////////////////////////////// struct S12051 { this(char c) { assert(c == 'P' || c == 'M'); } } void test12051() { auto ip = ["abc"]; foreach (i, s; ip) { S12051(i < ip.length ? 'P' : 'M'); } } //////////////////////////////////////////////////////////////////////// void bug7565( double x) { assert(x == 3); } void test7565() { double y = 3; bug7565( y++ ); assert(y == 4); } //////////////////////////////////////////////////////////////////////// int bug8525(int[] devt) { return devt[$ - 1]; } //////////////////////////////////////////////////////////////////////// void func13190(int) {} struct Struct13190 { ulong a; uint b; }; __gshared Struct13190* table13190 = [ Struct13190(1, 1), Struct13190(0, 2) ]; void test13190() { for (int i = 0; table13190[i].a; i++) { ulong tbl = table13190[i].a; func13190(i); if (1 + tbl) { if (tbl == 0x80000) return; } } } //////////////////////////////////////////////////////////////////////// double foo13485(double c, double d) { // This must not be optimized to c += (d + d) c += d; c += d; return c; } void test13485() { enum double d = 0X1P+1023; assert(foo13485(-d, d) == d); } //////////////////////////////////////////////////////////////////////// void test12833a(int a) { long x = cast(long)a; switch (cast(int)(cast(ushort)(x >> 16 & 65535L))) { case 1: { break; } default: { assert(0); } } } void test12833() { test12833a(0x1_0000); } /***********************************************/ struct Point9449 { double f = 3.0; double g = 4.0; } void test9449() { Point9449[1] arr; if (arr[0].f != 3.0) assert(0); if (arr[0].g != 4.0) assert(0); } struct Point9449x { float f = 0.0; double g = 0.0; } void test9449x() { Point9449x[1] arr; if (arr[0].f != 0.0) assert(0); if (arr[0].g != 0.0) assert(0); } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=12057 bool prop12057(real x) { return false; } double f12057(real) { return double.init; } void test12057() { real fc = f12057(real.init); if (fc == 0 || fc.prop12057) {} } //////////////////////////////////////////////////////////////////////// long modulo24 (long ticks) { ticks %= 864000000000; if (ticks < 0) ticks += 864000000000; return ticks; } void test13784() { assert (modulo24(-141600000000) == 722400000000); } //////////////////////////////////////////////////////////////////////// struct S13969 { int x, y; } int test13969(const S13969* f) { return 0 % ((f.y > 0) ? f.x / f.y : f.x / -f.y); } //////////////////////////////////////////////////////////////////////// int[] arr14436; void test14436() { assert(arr14436 == null); arr14436 = [1, 2, 3]; assert(arr14436 != null); } //////////////////////////////////////////////////////////////////////// void test14220() { auto a = toString(14); printf("a.ptr = %p, a.length = %d\n", a.ptr, cast(int)a.length); return; } auto toString(int value) { uint mValue = value; char[int.sizeof * 3] buffer = void; size_t index = buffer.length; do { uint div = cast(int)(mValue / 10); char mod = mValue % 10 + '0'; buffer[--index] = mod; // Line 22 mValue = div; } while (mValue); //printf("buffer.ptr = %p, index = %d\n", buffer.ptr, cast(int)index); return dup(buffer[index .. $]); } char[] dup(char[] a) { //printf("a.ptr = %p, a.length = %d\n", a.ptr, cast(int)a.length); a[0] = 1; // segfault return a; } //////////////////////////////////////////////////////////////////////// int stripLeft(int str, int dc) { while (true) { int a = str; int s = a; str += 1; if (dc) return s; } } void test14829() { if (stripLeft(3, 1) != 3) // fails with -O assert(0); } //////////////////////////////////////////////////////////////////////// void test3() { int[6] a; int[] b; b = a; b = (b.ptr + b.length - 5)[0 .. b.ptr + b.length - 1 - a.ptr]; assert(b.ptr == a.ptr + 1); assert(b.length == 5); } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=14782 void test14782() { static struct Foo { long a = 8; int b = 7; } static Foo[1] fun() { Foo[1] a; return a; } auto result = fun(); assert(result[0].a == 8); assert(result[0].b == 7); } //////////////////////////////////////////////////////////////////////// void test14987() { static struct Foo { int b = 7; } static assert((Foo[4]).sizeof == 16); static Foo[4] fun() { Foo[4] a; return a; } auto result = fun(); assert(result[0].b == 7); assert(result[1].b == 7); assert(result[2].b == 7); assert(result[3].b == 7); } //////////////////////////////////////////////////////////////////////// void[] calloc15272(size_t bc) nothrow pure { assert(bc == 1); return new void[1]; } void test15272() { void[] scache = cast(void[])"abc"; size_t count = 1; void[]* buckets = &scache; *buckets = calloc15272(count)[0 .. count]; } /***************************************** * https://issues.dlang.org/show_bug.cgi?id=15861 */ void test15861() { double val = 4286853117.; (){ assert(val == 4286853117.); }(); } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=15629 comment 3 // -O void test15629() { int[] a = [3]; int value = a[0] >= 0 ? a[0] : -a[0]; assert(a[0] == 3); writeln(value, a); } void writeln(int v, int[] a) { } //////////////////////////////////////////////////////////////////////// real binPosPow2() { return 1.0L; } real binPow2() { return 1.0L/binPosPow2(); } void test4() { assert(binPow2() == 1.0L); } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=13474 double sumKBN(double s = 0.0) { import core.math : fabs; double c = 0.0; foreach(double x; [1, 1e100, 1, -1e100]) { x = multiply(x); double t = s + x; if(s.fabs >= x.fabs) { double y = s-t; c += y+x; } else { double y = x-t; c += y+s; } s = t; } return s + c; } double multiply(double a) { return a * 10000; } void test13474() { double r = 20000; assert(r == sumKBN()); } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=16699 ulong[1] parseDateRange() { try { ulong[1] result; result[0] = 6; return result; } finally { } } void test16699() { ulong[1] range = parseDateRange(); assert(range[0] == 6); } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=16102 struct S16102 { ~this() { } } long[1] f16102() { S16102 a; return [1]; } void test16102() { assert( f16102() == [1] ); } //////////////////////////////////////////////////////////////////////// void test5a(ulong x, ulong y) { int a; if (x >> 32) a = 1; else a = 2; assert(a == 1); if (y >> 32) a = 1; else a = 2; assert(a == 2); } void test5() { test5a(uint.max + 1L, uint.max); } //////////////////////////////////////////////////////////////////////// /* Test the pattern: * replace (e ? i1 : i2) with (i1 + e * (i2 - i1)) * when e1 is 0 or 1 and (i2-i1) is a power of 2. */ int foo61(int i) { return (i % 2 != 0) ? 4 : 2; } int foo62(int i) { return (i % 2 != 0) ? 2 : 4; } bool bar6(bool b) { return b; } int foo63(bool b) { return bar6(b) ? 16 : 8; } int foo64(bool b) { return bar6(b) ? 8 : 16; } void test6() { if (foo61(0) != 2) assert(0); if (foo61(1) != 4) assert(0); if (foo62(0) != 4) assert(0); if (foo62(1) != 2) assert(0); if (foo63(0) != 8) assert(0); if (foo63(1) != 16) assert(0); if (foo64(0) != 16) assert(0); if (foo64(1) != 8) assert(0); } //////////////////////////////////////////////////////////////////////// int dataflow(int b) { int ret; if (b==4) ret = 3; else ret = 5; if (ret == 4) return 0; else return 1; } void testeqeqranges() { int i = dataflow(4); if (i != 1) assert(0); } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=16189 void test16189() { ubyte[9][1] data; uint a = 0; loop: data[0] = data[a]; a--; bool b = false; if (b) goto loop; assert(a == -1); // was failing with -O } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=16997 void test16997() { /* Exhaustively test all signed and unsigned byte promotions for * - + and ~ */ for (int i = 0; i < 256; ++i) { ubyte c = cast(ubyte)i; int i1 = cast(int)(~c); int i2 = cast(int)(~cast(int)c); //printf("%d, %d\n", i1, i2); assert(i1 == i2); i1 = cast(int)(+c); i2 = cast(int)(+cast(int)c); assert(i1 == i2); i1 = cast(int)(-c); i2 = cast(int)(-cast(int)c); assert(i1 == i2); } for (int i = 0; i < 256; ++i) { byte c = cast(byte)i; int i1 = cast(int)(~c); int i2 = cast(int)(~cast(int)c); //printf("%d, %d\n", i1, i2); assert(i1 == i2); i1 = cast(int)(+c); i2 = cast(int)(+cast(int)c); assert(i1 == i2); i1 = cast(int)(-c); i2 = cast(int)(-cast(int)c); assert(i1 == i2); } } //////////////////////////////////////////////////////////////////////// void test18315() // https://issues.dlang.org/show_bug.cgi?id=18315 { int i = int.min; bool b = i > 0; assert(!b); b = 0 < i; assert(!b); } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=18461 void test18461() { import core.bitop; size_t test_val = 0b0001_0000; if (bt(&test_val, 4) == 0) assert(false); } //////////////////////////////////////////////////////////////////////// void test18730() // https://issues.dlang.org/show_bug.cgi?id=18730 { static if (size_t.sizeof == 8) { static int bt18730_64_64(in ulong* p, ulong bitnum) pure @system { return ((p[bitnum >> 6] & (1L << (bitnum & 63)))) != 0; } static int bt18730_64_32(in ulong* p, uint bitnum) pure @system { return ((p[bitnum >> 6] & (1L << (bitnum & 63)))) != 0; } static int bt18730_32_64(in uint* p, ulong bitnum) pure @system { return ((p[bitnum >> 5] & (1 << (bitnum & 31)))) != 0; } // Check that bt_64_64 uses a 64-bit register for the offset. { enum bitIndex = int.max + 1L; auto a = new ulong[](bitIndex / 64 + 1); a[bitIndex / 64] = 1; assert(bt18730_64_64(a.ptr, bitIndex)); assert(!bt18730_64_64(a.ptr, bitIndex + 1)); assert(!bt18730_64_64(a.ptr, bitIndex - 1)); } // Check that bt_64_32 uses a 32-bit register for the offset. { static int f(ulong* p, ulong bitnum) { return bt18730_64_32(p, cast(uint) bitnum); } enum bitIndex = uint.max + 1L; assert(cast(uint) bitIndex == 0); ulong s = 1; assert(f(&s, bitIndex)); } /* Check that bt_32_64 does not become a 64-bit bt instruction. Would lead to a segfault when trying to load 8 bytes while only 4 are accessible. */ version (Posix) {{ import core.sys.posix.sys.mman; import core.sys.posix.unistd; // Allocate two pages. immutable sz = 2 * sysconf(_SC_PAGESIZE); auto m = mmap(null, sz, PROT_READ, MAP_PRIVATE | MAP_ANON, -1, 0); // Discard the higher page. It becomes unreadable. munmap(m + sz / 2, sz / 2); // Try looking at the last 4 bytes of the readable page. uint* p = cast(uint*) (m + sz / 2 - uint.sizeof); bt18730_32_64(p, 0); munmap(m, sz / 2); // Free the readable page. }} } } //////////////////////////////////////////////////////////////////////// void test19497() // https://issues.dlang.org/show_bug.cgi?id=19497 { { ubyte[1024] data; ushort* ushortPtr = cast(ushort*) data.ptr; *ushortPtr++ = 0xfe00; printf("ushortPtr(%p)\n", ushortPtr); fflush(stdout); } alias Seq(stuff ...) = stuff; static foreach (T; Seq!(ubyte, ushort, uint, ulong, byte, short, int, long)) {{ T[2] data = 0x2A; T* q = &data[0]; *q++ = cast(T) 0x1122334455667788; if (*q != 0x2A) assert(false); }} { static int toStringz(string s) { return s.length > 0 ? s[0] : 0; } static void toAStringz(in string[] a, int* az) { foreach (string s; a) { *az++ = toStringz(s); } } string[1] sa = ["abc"]; int[2] tgt = 0x2a; toAStringz(sa[], tgt.ptr); if (tgt[0] != 'a') assert(false); if (tgt[1] != 0x2a) assert(false); } } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=18794 bool method18794(size_t* p) { int bitIdx = 0; func18794(); return (*p & (1UL << bitIdx)) != 0; } void func18794() {} void prep18794() { asm {} ulong[2] x = -1; } void test18794() { prep18794(); size_t s; method18794(&s); } //////////////////////////////////////////////////////////////////////// /* Test the optimization * (e1+c)-e2 => (e1-e2)+c */ void testelmin() { static void foo(int i) { static ubyte[4] bar() { ubyte[4] array; foreach (i, ref a; array) a = cast(ubyte)(i + 1); return array; } static void test(int i, ubyte* p) { foreach (j; 0 .. 4) assert(p[i * 4 + j] == j + 1); } ubyte[32] data; data[i*4..(i+1)*4] = bar(); // optimize to single MOV test(i, data.ptr); } foo(4); } //////////////////////////////////////////////////////////////////////// const(char)* fastpar(string s) { return s.ptr + s.length; } void testfastpar() { string s = "abcde"; auto p = fastpar(s); assert(*p == 0); } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=20363 ulong foo20363(double d) { ulong u = * cast(ulong*) &d; return (u >> 1) & 1; } void test20363() { ulong u = 0b10; if (foo20363(*cast(double*) &u) == 0) assert(false); } //////////////////////////////////////////////////////////////////////// T testfooa(T)(T value) { return 10 - (value * 57); // gets rewritten into (value*-57)+10 } T testfoob(T)(T value) { return (value * -57) + 10; } void testNegConst() { assert(testfooa(1) == -47); assert(testfoob(1) == -47); assert(testfooa(1.0) == -47); assert(testfoob(1.0) == -47); } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=16317 int add8ret3(ref int s) { s += 8; return 3; } int binAdd(int val) { val = val + add8ret3(val); return val; } void test16317() { assert(binAdd(1) == (1 + 3)); static assert(binAdd(1) == (1 + 3)); } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=20050 int test20050_g = 0; void test20050_impure_function_1() { ++test20050_g; } void function() test20050_get_impure_function() pure { static void impure_function_2() { ++test20050_g; test20050_impure_function_1(); } return &impure_function_2; } void test20050() { auto f = test20050_get_impure_function(); f(); assert(test20050_g == 2); } //////////////////////////////////////////////////////////////////////// // https://github.com/dlang/dmd/pull/11238 int testCpStatic1(int y) { __gshared int yyy = 7; auto x = yyy; // no copy-propagation if (y) return x; return x + 3; } void testCpStatic() { assert(testCpStatic1(1) == 7); assert(testCpStatic1(0) == 10); } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=20991 int x7; void bar7(int i) { assert(i == x7); ++x7; } void test7() { for (int i = 0; i <= 1; ++i) bar7(i); assert(x7 == 2); } //////////////////////////////////////////////////////////////////////// // https://github.com/dlang/dmd/pull/11388 ushort byteswap(ushort x) pure { // Should be detected and XCHG instruction generated return cast(ushort) (((x >> 8) & 0xFF) | ((x << 8) & 0xFF00u)); } void testbyteswap() { assert(byteswap(0xF234) == 0x34F2); static ushort xx = 0xF234; assert(byteswap(xx) == 0x34F2); } //////////////////////////////////////////////////////////////////////// // These should all be recognized by the compiler and generate ROL or ROR // instructions. uint rol32(uint x, uint n) { return (x << n) | (x >> (32 - n)); } uint ror32(uint x, uint n) { return (x >> n) | (x << (32 - n)); } ulong rol64(ulong x, uint n) { return (x << n) | (x >> (64 - n)); } ulong ror64(ulong x, uint n) { return (x >> n) | (x << (64 - n)); } void testrolror() { assert(ror32(0x0123_4567u, 4) == 0x7012_3456); assert(rol32(0x7012_3456u, 4) == 0x0123_4567); assert(ror64(0x0123_4567_89AB_CDEFuL, 4) == 0xF012_3456_789A_BCDE); assert(rol64(0xF012_3456_789A_BCDEuL, 4) == 0x0123_4567_89AB_CDEF); } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=20162 void test20162() { static long f(long a) { assert(a == -1L); return a; } foreach (i; 1 .. 2) { foreach (j; 0 .. 2) { printf("%d %d %llx\n", i, ((i != 0) ? -1 : +1), f((i != 0) ? -1 : +1)); } } } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=3713 int star1(int i) { return i ? star1(i - 1) : 0; } int star2(int i) { return i == 0 ? 0 : star2(i - 1); } int star3(int i) { if (i == 0) return 0; return i == 2 ? star3(i - 2) : star3(i - 1); } int star4(int i) { return (i == 0) ? 0 : i != 2 ? star4(i - 1) : star4(i - 2); } void test3713() { assert(star1(10) == 0); assert(star2(10) == 0); assert(star3(10) == 0); assert(star4(10) == 0); } //////////////////////////////////////////////////////////////////////// void testsbbrex() { // special code is generated for these two cases static long foolt(dchar c) { return c < 0x10000 ? 1 : 2; } static long fooge(uint c) { return c >= 0x10000 ? 1L : 2L; } assert(foolt(0) == 1); assert(foolt(0x10000) == 2); assert(fooge(0) == 2); assert(fooge(0x10000) == 1); } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=19846 alias Void = byte[0]; static immutable Void VOID; // = []; __gshared int x19846; Void print19846() { //printf("This should print\n"); x19846 = 3; return VOID; } Void identity19846(Void value, out int i) { i = 7; return value; } void test19846() { int i; identity19846(print19846(), i); //printf("i = %d\n", i); assert(x19846 == 3); assert(i == 7); } //////////////////////////////////////////////////////////////////////// // Some tests for OPmemcpy enum N = 128; ubyte[N] def() { ubyte[N] array; foreach (i, ref a; array) a = cast(ubyte)(i + 1); return array; } void ghi(ubyte* p) { foreach (i; 0 .. N) assert(p[i] == i + 1); } void testmemcpy() { ubyte[N] bits; ubyte[N] bits2; bits2[0..N] = bits[0..N] = def(); ghi(bits.ptr); ghi(bits2.ptr); __gshared size_t n = N; ubyte[N] bits3; ubyte[N] bits4; bits4[0..n] = bits3[0..n] = def(); ghi(bits3.ptr); ghi(bits4.ptr); } //////////////////////////////////////////////////////////////////////// /* Test all the cases of uses of LEA for multiplication by a constant */ T testlea(uint C, T)(T x, T y) { y = y * C; // cdmul() x *= C; // cdmulass() return x + y; } void testleax(uint C)(uint X, uint Y) { assert(testlea!C(X,Y) == C * (X + Y)); assert(testlea!C(cast(long)X,cast(long)Y) == cast(long)C*X + cast(long)C*Y); } void testMulLea() { testleax!3(10,11); testleax!5(10,11); testleax!6(10,11); testleax!9(10,11); testleax!10(10,11); testleax!12(10,11); testleax!18(10,11); testleax!20(10,11); testleax!24(10,11); testleax!36(10,11); testleax!40(10,11); testleax!72(10,11); testleax!37(10,11); testleax!74(10,11); testleax!13(10,11); testleax!26(10,11); } //////////////////////////////////////////////////////////////////////// /* Test *= of register pair */ void testMulAssPair() { static ulong pow(ulong x, int m) { ulong v = x; ulong p = 1; while (1) { if (m & 1) p *= v; m >>= 1; if (!m) break; v *= v; } return p; } enum ulong e_10_pow_19 = 10uL^^19; assert(e_10_pow_19 == pow(10uL, 19)); } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=21038 const(wchar)* x21038 = "xz"; const(dchar)* name21038 = "abcd"; void test21038() { assert((cast(size_t) x21038) % wchar.sizeof == 0); assert((cast(size_t) name21038) % dchar.sizeof == 0); } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=21325 real f21325(const real x) pure @safe nothrow @nogc { return (x != 0.0L) ? x : real.nan; } void test21325() @safe { ulong x = 0uL; while(true) { const y = f21325(x); // should set y to real.nan assert(y != y); if (++x) return; // good } } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=16274 extern(C) int pair(short a, ushort b, byte c, ubyte d); struct S { // provide alternate implementation of .pair() pragma(mangle, "pair") extern(C) static void pair(int a, int b, int c, int d) { //printf("%d %d %d %d\n", a, b, c, d); assert(a == -1); assert(b == 2); assert(c == -3); assert(d == 4); } } void test16274() { version (X86_64) pair(-1, 2, -3, 4); version (X86) pair(-1, 2, -3, 4); } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=16268 void test16268() { static void f(byte x) { for (byte i = 0; i <= x && i >= 0; ++i) { assert(i >= 0); assert(i != -1); //printf("%d\n", i); } } f(byte.max); } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=11435 void test11435a() { alias T = byte; static void fun(T c, T b, int v) { } static void abc(T[] b) { fun(b[0], b[1], 0); } version(Windows) { import core.sys.windows.windows; auto p = VirtualAlloc(null, 4096, MEM_COMMIT, PAGE_EXECUTE_READWRITE); } else { import core.sys.posix.sys.mman; auto p = mmap(null, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, 0L); } assert(p); auto px = (cast(T*)(p + 4096 - 2 * T.sizeof)); abc(px[0..2]); } void test11435b() { import core.sys.windows.windows; alias T = short; static void fun(T c, T b, int v) { } static void abc(T[] b) { fun(b[0], b[1], 0); } version(Windows) { import core.sys.windows.windows; auto p = VirtualAlloc(null, 4096, MEM_COMMIT, PAGE_EXECUTE_READWRITE); } else { import core.sys.posix.sys.mman; auto p = mmap(null, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, 0L); } assert(p); auto px = (cast(T*)(p + 4096 - 2 * T.sizeof)); abc(px[0..2]); } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=21513 struct Stuff { size_t c; // declare after items and not crash ! ubyte[1] items; } void grow(ref Stuff stuff) { with (stuff) { const oldCapacity = c; items.ptr[0..oldCapacity] = items.ptr[0..0]; // use literal 0 instead of items.ptr[0] = 0; // oldcapacity and no crash ! } } void test21513() { Stuff stuff; grow(stuff); } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=21526 double f21256(double a, double b) { double c = a + b; return c; } void test21256() { union DX { double d; ulong l; } DX a, b; a.l = 0x4341c37937e08000; b.l = 0x4007ffcb923a29c7; DX r; r.d = f21256(a.d, b.d); //if (r.d != 0x1.1c37937e08001p+53) //printf("r = %A should be 0x1.1c37937e08001p+53 %A\n", r.d, 0x1.1c37937e08001p+53); //assert(r == 0x1.1c37937e08001p+53); // cannot seem to get the two to produce the same value assert(r.l == 0x4341c37937e08001 || // value using XMM r.l == 0x4341c37937e08002); // value using x87 } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=21816 bool test21816a(float t) { return cast(bool)t; } void test21816() { assert(test21816a(float.nan)); } //////////////////////////////////////////////////////////////////////// // https://issues.dlang.org/show_bug.cgi?id=21835 struct Point21835 { float f = 3.0; double d = 4.0; real r = 5.0; } void test21835y() { Point21835[1] arr; if (arr[0].f != 3.0) assert(0); if (arr[0].d != 4.0) assert(0); if (arr[0].r != 5.0) assert(0); } struct Point21835x { float f = 0.0; double d = 0.0; real r = 0.0; } void test21835() { test21835y(); Point21835x[1] arr; if (arr[0].f != 0.0) assert(0); if (arr[0].d != 0.0) assert(0); if (arr[0].r != 0.0) assert(0); } //////////////////////////////////////////////////////////////////////// int main() { // All the various integer divide tests testsdiv2(); testulldiv(); testfastudiv(); testsldiv(); testslmod(); testfastdiv(); testdivdiv(); testdivcmp(); testgoto(); testswitch(); testdo(); testbreak(); teststringswitch(); teststrarg(); test12164(); testsizes(); testarrayinit(); testU(); testbittest(); test8658(); test3918(); test12051(); testdocond(); testnegcom(); test11565(); test23743(); testoror(); testbt(); test12095(0); testandand(); testor_combine(); testshrshl(); test13383(); test13190(); test13485(); test14436(); test10715(); test10678(); test7565(); test13023(0x10_0000_0000); test12833(); test9449(); test9449x(); test12057(); test13784(); test14220(); test14829(); test3(); test14782(); test14987(); test15272(); test15861(); test15629(); test4(); test13474(); test16699(); test16102(); test5(); test6(); testeqeqranges(); test16189(); test16997(); test18315(); test18461(); test18730(); test19497(); test18794(); testelmin(); testfastpar(); test20363(); testNegConst(); test16317(); test20050(); testCpStatic(); test7(); testbyteswap(); testrolror(); test20162(); test3713(); testsbbrex(); test19846(); testmemcpy(); testMulLea(); testMulAssPair(); test21038(); test21325(); test16274(); test16268(); test11435a(); test11435b(); test21513(); test21256(); test21816(); test21835(); printf("Success\n"); return 0; }