Fix a number of tests to work correctly with 32/64-wide targets.

Still to be reviewed/fixed: tests/test-*, tests/[cfrs]*

tests/acos.ispc

@@ -6,14 +6,14 @@ bool ok(float x, float ref) { return (abs(x - ref) < 1e-6) || abs((x-ref)/ref) <
 
 export void f_v(uniform float RET[]) {
     uniform float vals[8] = { 0, 1, 0.5, -1, -.87, -.25, 1e-3, -.99999999 };
-    uniform float r[8];
+    uniform float r[programCount];
     foreach (i = 0 ... 8)
-        r[i] = cos(acos(vals[i]));
+        r[i] = cos(acos(vals[i % 8]));
 
     int errors = 0;
     for (uniform int i = 0; i < 8; ++i) {
-        if (ok(r[i], vals[i]) == false) {
-            print("error @ %: got %, expected %\n", i, r[i], vals[i]);
+        if (ok(r[i], vals[i%8]) == false) {
+            print("error @ %: got %, expected %\n", i, r[i], vals[i%8]);
             ++errors;
         }
     }

tests/aossoa-1.ispc

@@ -3,7 +3,9 @@ export uniform int width() { return programCount; }
 
 export void f_v(uniform float RET[]) {
 #define width 3
-#define maxProgramCount 16
+#define maxProgramCount 64
+    assert(programCount <= maxProgramCount);
+
 //CO    const uniform int width = 3;
 //CO    const uniform int maxProgramCount = 16;
     uniform float a[width*maxProgramCount], r[width*maxProgramCount];

tests/aossoa-2.ispc

@@ -3,7 +3,9 @@ export uniform int width() { return programCount; }
 
 export void f_v(uniform float RET[]) {
 #define width 4
-#define maxProgramCount 16
+#define maxProgramCount 64
+    assert(programCount <= maxProgramCount);
+
 //CO    const uniform int width = 4;
 //CO    const uniform int maxProgramCount = 16;
     uniform float a[width*maxProgramCount], r[width*maxProgramCount];

tests/aossoa-5.ispc

@@ -3,7 +3,9 @@ export uniform int width() { return programCount; }
 
 export void f_v(uniform float RET[]) {
 #define width 3
-#define maxProgramCount 16
+#define maxProgramCount 64
+    assert(programCount <= maxProgramCount);
+
 //CO    const uniform int width = 3;
 //CO    const uniform int maxProgramCount = 16;
     uniform int a[width*maxProgramCount], r[width*maxProgramCount];

tests/aossoa-6.ispc

@@ -3,7 +3,9 @@ export uniform int width() { return programCount; }
 
 export void f_v(uniform float RET[]) {
 #define width 4
-#define maxProgramCount 16
+#define maxProgramCount 64
+    assert(programCount <= maxProgramCount);
+
 //CO    const uniform int width = 4;
 //CO    const uniform int maxProgramCount = 16;
     uniform int a[width*maxProgramCount], r[width*maxProgramCount];

tests/array-gather-ifs.ispc

@@ -5,9 +5,9 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    uniform float x[45];
+    uniform float x[programCount+15];
     uniform int i;
-    for (i = 0; i < 45; ++i)
+    for (i = 0; i < programCount+15; ++i)
         x[i] = i;
 
     float ret;

tests/array-gather-multi-unif.ispc

@@ -10,7 +10,8 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     for (uniform int i = 0; i < 29+b; ++i)
         for (uniform int j = 0; j < 29+b; ++j)
             x[i][j] = 0;
-    x[a][a] = a;
+    if (a < 34)
+        x[a][a] = a;
     RET[programIndex] = x[4][4] + x[1][1] + x[b][b] + x[0][0];
 }
 

tests/array-gather-simple.ispc

@@ -12,8 +12,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 }
 
 export void result(uniform float RET[]) { 
-    RET[0] = 1; RET[4] = 5; RET[8] = 9; RET[12] = 13;
-    RET[1] = RET[5] = RET[9] = RET[13] = 0;
-    RET[2] = 6; RET[6] = 14; RET[10] = 22; RET[14] = 30;
-    RET[3] = RET[7] = RET[11] = RET[15] = 3;
+    for (uniform int i = 0; i < programCount; i += 4) {
+        RET[i] = i+1;
+        RET[i+1] = 0;
+        RET[i+2] = 2 * (i+3);
+        RET[i+3] = 3;
+    }
 }

tests/array-gather-unif-runflags.ispc

@@ -4,9 +4,9 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    uniform float x[45];
+    uniform float x[programCount+5];
     uniform int i;
-    for (i = 0; i < 45; ++i)
+    for (i = 0; i < programCount+5; ++i)
         x[i] = i+b;
     a -= 1;
     if (a == 3) a = 0;

tests/array-gather-unif.ispc

@@ -4,9 +4,9 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    uniform float x[45];
+    uniform float x[programCount+5];
     uniform int i;
-    for (i = 0; i < 45; ++i)
+    for (i = 0; i < programCount+5; ++i)
         x[i] = i+b;
     RET[programIndex] = x[a];
 }

tests/array-gather-vary.ispc

@@ -4,14 +4,14 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    float x[55];
+    float x[programCount+10];
     uniform int i;
-    for (i = 0; i < 45; ++i)
+    for (i = 0; i < programCount+10; ++i)
         x[i] = a+b;
     RET[programIndex] = x[a];
 }
 
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = 6 + programIndex;;
+    RET[programIndex] = 6 + programIndex;
 }

tests/array-mixed-unif-vary-indexing-2.ispc

@@ -15,6 +15,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
         x[a][b-1] = 0;
     else
         x[a][b-1] = 1;
+
+    a = min(a, 46);
+
     RET[programIndex] = x[3][a];
 }
 

tests/array-mixed-unif-vary-indexing-3.ispc

@@ -4,9 +4,10 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    uniform float x[47][47];
-    for (uniform int i = 0; i < 47; ++i)
-        for (uniform int j = 0; j < 47; ++j)
+    assert(programCount <= 64);
+    uniform float x[70][70];
+    for (uniform int i = 0; i < 70; ++i)
+        for (uniform int j = 0; j < 70; ++j)
             x[i][j] = 2+b-5;
 
     // all are 2 except (4,2) = 0, (4,...) = 1, (4,programCount-1)=2

tests/array-mixed-unif-vary-indexing.ispc

@@ -10,6 +10,7 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
         for (uniform int j = 0; j < 47; ++j)
             x[i][j] = 2+b-5;
 
+    a = min(a,46);
     x[a][b-1] = 0;
     RET[programIndex] = x[2][a];
 }

tests/array-multidim-gather-scatter.ispc

@@ -11,7 +11,7 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
     uniform int index[4] = { 0, 1, 2, 4 };
     float v = index[programIndex & 0x3];
-    x[a][v] = 0;
+    x[min(a,39)][v] = 0;
     RET[programIndex] = x[v+1][v];
 }
 

tests/array-scatter-unif-2.ispc

@@ -4,9 +4,8 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    uniform float x[100];
-    // HACK to avoid @llvm.memset...
-    for (uniform int i = 0; i < b*20; ++i)
+    uniform float x[2*programCount];
+    for (uniform int i = 0; i < 2*programCount; ++i)
         x[i] = 0;
     
     x[2*(a-1)] = b;

tests/array-scatter-unif-3.ispc

@@ -4,9 +4,8 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    uniform float x[100];
-    // HACK to avoid @llvm.memset...
-    for (uniform int i = 0; i < b*20; ++i)
+    uniform float x[2*programCount];
+    for (uniform int i = 0; i < 2*programCount; ++i)
         x[i] = 0;
 
     x[2*(a-1)] = b;

tests/array-scatter-unif.ispc

@@ -5,8 +5,8 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    uniform float x[40];
-    for (uniform int i = 0; i < 40; ++i)
+    uniform float x[programCount+5];
+    for (uniform int i = 0; i < programCount+5; ++i)
         x[i] = 0.;
     x[a] = 2;
     RET[programIndex] = x[4] + x[0] + x[5];

tests/array-scatter-vary.ispc

@@ -4,9 +4,8 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    float x[30];
-    // HACK to avoid @llvm.memset...
-    for (uniform int i = 0; i < b*6; ++i)
+    float x[2*programCount];
+    for (uniform int i = 0; i < 2*programCount; ++i)
         x[i] = 0;
     x[a] = a;
     RET[programIndex] = x[4] + x[0] + x[5];

tests/array-struct-gather.ispc

@@ -4,14 +4,14 @@ export uniform int width() { return programCount; }
 
 
 struct Foo {
-    uniform float x[17];
+    uniform float x[programCount+1];
 };
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
     uniform Foo foo;
     uniform int i;
-    for (i = 0; i < 17; ++i)
+    for (i = 0; i < programCount+1; ++i)
         foo.x[i] = i;
 
     if ((int)a & 1)

tests/asin.ispc

@@ -8,12 +8,12 @@ export void f_v(uniform float RET[]) {
     uniform float vals[8] = { 0, 1, 0.5, -1, -.87, -.25, 1e-3, -.99999999 };
     uniform float r[8];
     foreach (i = 0 ... 8)
-        r[i] = sin(asin(vals[i]));
+        r[i] = sin(asin(vals[i%8]));
 
     int errors = 0;
     for (uniform int i = 0; i < 8; ++i) {
-        if (ok(r[i], vals[i]) == false) {
-            print("error @ %: got %, expected %\n", i, r[i], vals[i]);
+        if (ok(r[i], vals[i%8]) == false) {
+            print("error @ %: got %, expected %\n", i, r[i], vals[i%8]);
             ++errors;
         }
     }

tests/atomics-12.ispc

@@ -6,14 +6,14 @@ uniform unsigned int32 s = 0;
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
     float b = 0;
-    if (programIndex & 1)
+    if (programIndex < 30 && programIndex & 1)
         b = atomic_or_global(&s, (1 << programIndex));
     RET[programIndex] = s;
 }
 
 export void result(uniform float RET[]) {
     uniform int sum = 0;
-    for (uniform int i = 0; i < programCount; ++i)
+    for (uniform int i = 0; i < min(30, programCount); ++i)
         if (i & 1)
             sum += (1 << i);
     RET[programIndex] = sum;

tests/atomics-13.ispc

@@ -5,12 +5,12 @@ uniform unsigned int32 s = 0;
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
-    float b = 0;
-    if (programIndex & 1)
+    int32 b = 0;
+    if (programIndex < 32 && programIndex & 1)
         b = atomic_or_global(&s, (1 << programIndex));
     RET[programIndex] = popcnt(reduce_max((int32)b));
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = programCount == 1 ? 0 : ((programCount/2) - 1);
+    RET[programIndex] = programCount == 1 ? 0 : ((min(32, programCount)/2) - 1);
 }

tests/atomics-14.ispc

@@ -7,14 +7,14 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
     float b = 0;
     if (programIndex & 1)
-        b = atomic_or_global(&s, (1 << programIndex));
+        b = atomic_or_global(&s, (1ull << programIndex));
     RET[programIndex] = (s>>20);
 }
 
 export void result(uniform float RET[]) {
-    uniform int sum = 0;
+    uniform int64 sum = 0;
     for (uniform int i = 0; i < programCount; ++i)
         if (i & 1)
-            sum += (1 << i);
+            sum += (1ull << i);
     RET[programIndex] = ((unsigned int64)(0xffffffffff000000 | sum)) >> 20;
 }

tests/atomics-4.ispc

@@ -5,10 +5,10 @@ uniform int32 s = 0;
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
-    float b = atomic_or_global(&s, (1<<programIndex));
+    float b = atomic_or_global(&s, (1<<min(programIndex,30)));
     RET[programIndex] = s;
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = (1<<programCount)-1;
+    RET[programIndex] = (1<<min(programCount,31))-1;
 }

tests/exclusive-scan-add-1.ispc

@@ -5,8 +5,17 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     RET[programIndex] = exclusive_scan_add(programIndex); 
 }
 
-export void result(uniform float RET[]) {
-    uniform int result[] = { 0, 0, 1, 3, 6, 10, 15, 21, 28,
-                             36, 45, 55, 66, 78, 91, 105, 120 };
-    RET[programIndex] = result[programIndex]; 
+int es(int v) {
+    uniform int vv[programCount];
+    vv[programIndex] = v;
+
+    uniform int r[programCount];
+    r[0] = 0;
+    for (uniform int i = 1; i < programCount; ++i)
+        r[i] = r[i-1] + vv[i-1];
+    return r[programIndex];
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = es(programIndex); 
 }

tests/exclusive-scan-add-10.ispc

@@ -10,11 +10,19 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
 }
 
 
+int es(int v) {
+    uniform int vv[programCount];
+    vv[programIndex] = v;
+
+    uniform int r[programCount];
+    r[0] = 0;
+    for (uniform int i = 1; i < programCount; ++i)
+        r[i] = r[i-1] + vv[i-1];
+    return r[programIndex];
+}
+
 export void result(uniform float RET[]) {
-    uniform int result[16] = { 0, 0, 0, 2, 0, 6, 0, 12, 
-                               0, 20, 0, 30, 0, 42, 0, 56 };
-    if (programIndex & 1)
-        RET[programIndex] = result[programIndex]; 
-    else
+    RET[programIndex] = es((programIndex & 1) ? (programIndex+1) : 0);
+    if ((programIndex & 1) == 0)
         RET[programIndex] = -1;
 }

tests/exclusive-scan-add-2.ispc

@@ -5,8 +5,17 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     RET[programIndex] = exclusive_scan_add(aFOO[programIndex]);
 }
 
-export void result(uniform float RET[]) {
-    uniform int result[] = { 0, 1, 3, 6, 10, 15, 21, 28,
-                             36, 45, 55, 66, 78, 91, 105, 120, 136 };
-    RET[programIndex] = result[programIndex]; 
+int es(int v) {
+    uniform int vv[programCount];
+    vv[programIndex] = v;
+
+    uniform int r[programCount];
+    r[0] = 0;
+    for (uniform int i = 1; i < programCount; ++i)
+        r[i] = r[i-1] + vv[i-1];
+    return r[programIndex];
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = es(programIndex+1); 
 }

tests/exclusive-scan-add-3.ispc

@@ -9,8 +9,7 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
 }
 
 export void result(uniform float RET[]) {
-    uniform int result[] = { 0, 1, 3, 0, 0, 0, 0, 0,
-                             0, 0, 0, 0, 0, 0, 0, 0 };
+    uniform int result[] = { 0, 1, 3 };
     RET[programIndex] = -1;
     if (programIndex <= 1)
         RET[programIndex] = result[programIndex]; 

tests/exclusive-scan-add-5.ispc

@@ -9,12 +9,20 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     }
 }
 
+int es(int v) {
+    uniform int vv[programCount];
+    vv[programIndex] = v;
+
+    uniform int r[programCount];
+    r[0] = 0;
+    for (uniform int i = 1; i < programCount; ++i)
+        r[i] = r[i-1] + vv[i-1];
+    return r[programIndex];
+}
+
 
 export void result(uniform float RET[]) {
-    uniform int result[16] = { 0, 0, 0, 2, 0, 6, 0, 12, 
-                               0, 20, 0, 30, 0, 42, 0, 56 };
-    if (programIndex & 1)
-        RET[programIndex] = result[programIndex]; 
-    else
+    RET[programIndex] = es((programIndex & 1) ? (programIndex+1) : 0);
+    if ((programIndex & 1) == 0)
         RET[programIndex] = -1;
 }

tests/exclusive-scan-add-6.ispc

@@ -5,8 +5,17 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     RET[programIndex] = exclusive_scan_add((float)programIndex); 
 }
 
-export void result(uniform float RET[]) {
-    uniform int result[] = { 0, 0, 1, 3, 6, 10, 15, 21, 28,
-                             36, 45, 55, 66, 78, 91, 105, 120 };
-    RET[programIndex] = result[programIndex]; 
+int es(int v) {
+    uniform int vv[programCount];
+    vv[programIndex] = v;
+
+    uniform int r[programCount];
+    r[0] = 0;
+    for (uniform int i = 1; i < programCount; ++i)
+        r[i] = r[i-1] + vv[i-1];
+    return r[programIndex];
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = es(programIndex); 
 }

tests/exclusive-scan-add-7.ispc

@@ -5,8 +5,17 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     RET[programIndex] = exclusive_scan_add((double)aFOO[programIndex]);
 }
 
-export void result(uniform float RET[]) {
-    uniform int result[] = { 0, 1, 3, 6, 10, 15, 21, 28,
-                             36, 45, 55, 66, 78, 91, 105, 120, 136 };
-    RET[programIndex] = result[programIndex]; 
+int es(int v) {
+    uniform int vv[programCount];
+    vv[programIndex] = v;
+
+    uniform int r[programCount];
+    r[0] = 0;
+    for (uniform int i = 1; i < programCount; ++i)
+        r[i] = r[i-1] + vv[i-1];
+    return r[programIndex];
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = es(programIndex+1); 
 }

tests/exclusive-scan-and-2.ispc

@@ -4,7 +4,7 @@ export uniform int width() { return programCount; }
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     RET[programIndex] = -1;
     int32 a = ~(1 << programIndex);
-    if ((programIndex & 1) == 0) {
+    if ((programIndex < 32) && (programIndex & 1) == 0) {
         RET[programIndex] = exclusive_scan_and(a);
     }
 }
@@ -12,7 +12,7 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
 
 export void result(uniform float RET[]) {
     RET[programIndex] = -1;
-    if ((programIndex & 1) == 0 && programIndex > 0) {
+    if ((programIndex & 1) == 0 && programIndex > 0 && programIndex < 32) {
         int val = 0xffffffff;
         for (int i = 0; i < programIndex-1; i += 2)
             val &= ~(1<<i);

tests/exclusive-scan-or-1.ispc

@@ -3,11 +3,11 @@ export uniform int width() { return programCount; }
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     RET[programIndex] = -1;
-    int32 a = (1 << programIndex);
+    int32 a = (1 << (min(programIndex, 30)));
     RET[programIndex] = exclusive_scan_or(a);
 }
 
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = (1 << programIndex) - 1;
+    RET[programIndex] = (1 << (min(programIndex, 31))) - 1;
 }

tests/gs-double-improve-multidim-1.ispc

@@ -4,9 +4,9 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex]; 
-    uniform double udx[25][25];
-    for (uniform int i = 0; i < 25; ++i)
-        for (uniform int j = 0; j < 25; ++j)
+    uniform double udx[5][programCount+5];
+    for (uniform int i = 0; i < 5; ++i)
+        for (uniform int j = 0; j < programCount+5; ++j)
             udx[i][j] = 10*i+j;
 
     int x = 1;

tests/gs-double-improve-multidim-struct-1.ispc

@@ -4,15 +4,15 @@ export uniform int width() { return programCount; }
 
 
 struct Foo {
-    uniform double udx[5][35];
+    uniform double udx[5][programCount+5];
 };
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex]; 
-    uniform Foo f[5];
-    for (uniform int i = 0; i < 5; ++i)
+    uniform Foo f[3];
+    for (uniform int i = 0; i < 3; ++i)
         for (uniform int j = 0; j < 5; ++j)
-            for (uniform int k = 0; k < 35; ++k)
+            for (uniform int k = 0; k < programCount+5; ++k)
                 f[i].udx[j][k] = 100*i+10*j+k;
 
     int x = 1;

tests/gs-double-improve-progindex-plus-const.ispc

@@ -5,9 +5,11 @@ export uniform int width() { return programCount; }
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex]; 
     uniform double udx[17] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17 };
-    int x = programIndex + 1;
+    int x = (programIndex + 1) % 17;
     RET[programIndex] = udx[x];
 }
 
-export void result(uniform float RET[]) { RET[programIndex] = 2+programIndex; }
+export void result(uniform float RET[]) { 
+    RET[programIndex] = 1+((1+programIndex)%17); 
+}
 

tests/gs-double-improve-progindex-plus-unif.ispc

@@ -6,7 +6,7 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex]; 
     uniform double udx[16] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16 };
     int x = -5 + programIndex + (int)b;
-    RET[programIndex] = udx[x];
+    RET[programIndex] = udx[x % 16];
 }
 
-export void result(uniform float RET[]) { RET[programIndex] = 1+programIndex; }
+export void result(uniform float RET[]) { RET[programIndex] = 1+(programIndex%16); }

tests/gs-double-improve-progindex.ispc

@@ -4,7 +4,9 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex]; 
-    uniform double udx[16] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16 };
+    uniform double udx[programCount];
+    for (uniform int i = 0; i < programCount; ++i)
+        udx[i] = i+1;
     int x = programIndex;
     RET[programIndex] = udx[x];
 }

tests/gs-improve-multidim-1.ispc

@@ -5,9 +5,9 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex]; 
-    uniform float udx[20][20];
-    for (uniform int i = 0; i < 20; ++i)
-        for (uniform int j = 0; j < 20; ++j)
+    uniform float udx[2][programCount+5];
+    for (uniform int i = 0; i < 2; ++i)
+        for (uniform int j = 0; j < programCount+5; ++j)
             udx[i][j] = 100*i+j;
 
     int x = 1;

tests/gs-improve-multidim-struct-1.ispc

@@ -4,15 +4,15 @@ export uniform int width() { return programCount; }
 
 
 struct Foo {
-    uniform float udx[25][25];
+    uniform float udx[5][programCount+5];
 };
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex]; 
-    uniform Foo f[5];
-    for (uniform int i = 0; i < 5; ++i)
-        for (uniform int j = 0; j < 25; ++j)
-            for (uniform int k = 0; k < 25; ++k)
+    uniform Foo f[3];
+    for (uniform int i = 0; i < 3; ++i)
+        for (uniform int j = 0; j < 5; ++j)
+            for (uniform int k = 0; k < programCount+5; ++k)
                 f[i].udx[j][k] = 1000*i+100*j+k;
 
     int x = 1;

tests/gs-improve-progindex-plus-const.ispc

@@ -5,7 +5,9 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex]; 
-    uniform float udx[17] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17 };
+    uniform float udx[programCount+1];
+    for (uniform int i = 0; i < programCount + 1; ++i)
+        udx[i] = i+1;
     int x = programIndex + 1;
     RET[programIndex] = udx[x];
 }

tests/gs-improve-progindex-plus-unif.ispc

@@ -5,7 +5,9 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex]; 
-    uniform float udx[16] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16 };
+    uniform float udx[programCount];
+    for (uniform int i = 0; i < programCount; ++i)
+        udx[i] = i+1;
     int x = -5 + programIndex + (int)b;
     RET[programIndex] = udx[x];
 }

tests/gs-improve-progindex.ispc

@@ -5,7 +5,9 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex]; 
-    uniform float udx[16] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16 };
+    uniform float udx[programCount+1];
+    for (uniform int i = 0; i < programCount + 1; ++i)
+        udx[i] = i+1;
     int x = programIndex;
     RET[programIndex] = udx[x];
 }

tests/ldexp-double.ispc

@@ -3,14 +3,15 @@ export uniform int width() { return programCount; }
 
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
-    double a = 1 << (programIndex);
+    double a = 1 << (programIndex % 28);
     if (programIndex & 1)
         a = -a;
     RET[programIndex] = ldexp(a, 2);
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = (1 << (programIndex + 2));
+    int pi = programIndex % 28;
+    RET[programIndex] = (1 << (pi + 2));
     if (programIndex & 1)
         RET[programIndex] = -RET[programIndex];
 }

tests/ldexp-float.ispc

@@ -3,14 +3,15 @@ export uniform int width() { return programCount; }
 
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
-    float a = 1 << (programIndex);
+    float a = 1 << (programIndex % 28);
     if (programIndex & 1)
         a = -a;
     RET[programIndex] = ldexp(a, 2);
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = (1 << (programIndex + 2));
+    int pi = programIndex % 28;
+    RET[programIndex] = (1 << (pi + 2));
     if (programIndex & 1)
         RET[programIndex] = -RET[programIndex];
 }

tests/local-atomics-10.ispc

@@ -13,5 +13,5 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = programCount == 1 ? 1 : 2;
+    RET[programIndex] = (programCount == 1) ? 1 : 2;
 }

tests/local-atomics-12.ispc

@@ -6,14 +6,14 @@ uniform unsigned int32 s = 0;
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
     float b = 0;
-    if (programIndex & 1)
+    if (programIndex < 29 && (programIndex & 1))
         b = atomic_or_local(&s, (1 << programIndex));
     RET[programIndex] = s;
 }
 
 export void result(uniform float RET[]) {
     uniform int sum = 0;
-    for (uniform int i = 0; i < programCount; ++i)
+    for (uniform int i = 0; i < min(programCount, 29); ++i)
         if (i & 1)
             sum += (1 << i);
     RET[programIndex] = sum;

tests/local-atomics-13.ispc

@@ -5,12 +5,12 @@ uniform unsigned int32 s = 0;
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
-    float b = 0;
-    if (programIndex & 1)
+    int32 b = 0;
+    if (programIndex < 28 && (programIndex & 1))
         b = atomic_or_local(&s, (1 << programIndex));
-    RET[programIndex] = popcnt(reduce_max((int32)b));
+    RET[programIndex] = popcnt(reduce_max(b));
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = programCount == 1 ? 0 : ((programCount/2) - 1);
+    RET[programIndex] = (programCount == 1) ? 0 : ((min(28, programCount)/2) - 1);
 }

tests/local-atomics-14.ispc

@@ -6,14 +6,14 @@ uniform unsigned int64 s = 0xffffffffff000000;
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
     float b = 0;
-    if (programIndex & 1)
+    if (programIndex < 32 && (programIndex & 1))
         b = atomic_or_local(&s, (1 << programIndex));
     RET[programIndex] = (s>>20);
 }
 
 export void result(uniform float RET[]) {
     uniform int sum = 0;
-    for (uniform int i = 0; i < programCount; ++i)
+    for (uniform int i = 0; i < min(32, programCount); ++i)
         if (i & 1)
             sum += (1 << i);
     RET[programIndex] = ((unsigned int64)(0xffffffffff000000 | sum)) >> 20;

tests/local-atomics-4.ispc

@@ -5,10 +5,12 @@ uniform int32 s = 0;
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
-    float b = atomic_or_local(&s, (1<<programIndex));
+    float b = 0;
+    if (programIndex < 29)
+        atomic_or_local(&s, (1<<programIndex));
     RET[programIndex] = s;
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = (1<<programCount)-1;
+    RET[programIndex] = (1<<min(29,programCount))-1;
 }

tests/local-atomics-7.ispc

@@ -5,10 +5,13 @@ uniform int32 s = 0;
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     int32 a = aFOO[programIndex]; 
-    float b = atomic_min_local(&s, a);
+    float b = 0;
+    if (programIndex < 32)
+        atomic_min_local(&s, a);
     RET[programIndex] = reduce_min(b);
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = reduce_min(programIndex);
+    int pi = (programIndex < 32) ? programIndex : 0;
+    RET[programIndex] = reduce_min(pi);
 }

tests/local-atomics-swap.ispc

@@ -13,5 +13,5 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = 1234 + reduce_add(programIndex & 1 ? programIndex : 0);
+    RET[programIndex] = 1234 + reduce_add((programIndex & 1) ? programIndex : 0);
 }

tests/masked-scatter-struct.ispc

@@ -5,8 +5,8 @@ struct Foo { float x; float y; };
 
 export void f_fu(uniform float ret[], uniform float aa[], uniform float b) {
     float a = aa[programIndex];
-    uniform Foo foo[32];
-    for (uniform int i = 0; i < 32; ++i) {
+    uniform Foo foo[programCount];
+    for (uniform int i = 0; i < programCount; ++i) {
         foo[i].x = i;
         foo[i].y = -1234 + i;
     }

tests/masked-scatter-vector.ispc

@@ -5,8 +5,8 @@ typedef int<3> int3;
 
 export void f_fu(uniform float ret[], uniform float aa[], uniform float b) {
     float a = aa[programIndex];
-    uniform int3 array[32];
-    for (uniform int i = 0; i < 6*b + 2; ++i) {
+    uniform int3 array[programCount];
+    for (uniform int i = 0; i < programCount + 5 - b; ++i) {
         for (uniform int j = 0; j < 3; ++j)
             array[i][j] = i+100*j;
     }

tests/masked-struct-scatter-varying.ispc

@@ -5,8 +5,8 @@ struct Foo { float x; float y; };
 
 export void f_fu(uniform float ret[], uniform float aa[], uniform float b) {
     float a = aa[programIndex];
-    Foo foo[32];
-    for (uniform int i = 0; i < 32; ++i)
+    Foo foo[programCount+1];
+    for (uniform int i = 0; i < programCount+1; ++i)
         foo[i].x = i;
     varying Foo fv = foo[a];
     fv.x += 1000;

tests/max-int-1.ispc

@@ -6,8 +6,8 @@ export uniform int width() { return programCount; }
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex];
     int i = (int)a;
-    RET[programIndex] = max((int)20, i);
+    RET[programIndex] = max((int)200, i);
 }
 
-export void result(uniform float RET[]) { RET[programIndex] = 20.; }
+export void result(uniform float RET[]) { RET[programIndex] = 200.; }
 

tests/min-float.ispc

@@ -5,7 +5,7 @@ export uniform int width() { return programCount; }
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex];
-    RET[programIndex] = min(a, 20.f);
+    RET[programIndex] = min(a, 200.f);
 }
 
 export void result(uniform float RET[]) { RET[programIndex] = 1+programIndex; }

tests/min-int.ispc

@@ -6,7 +6,7 @@ export uniform int width() { return programCount; }
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex];
     int i = (int)a;
-    RET[programIndex] = min((int)20, i);
+    RET[programIndex] = min((int)200, i);
 }
 
 export void result(uniform float RET[]) { RET[programIndex] = 1+programIndex; }

tests/min-uint-2.ispc

@@ -3,7 +3,7 @@ export uniform int width() { return programCount; }
 
 export void f_f(uniform float r[], uniform float a[]) {
     unsigned int i = (unsigned int)a[programIndex];
-    r[programIndex] =  min((unsigned int)20, i);
+    r[programIndex] =  min((unsigned int)200, i);
 }
 
 export void result(uniform float r[]) { 

tests/nested-structs-2.ispc

@@ -4,7 +4,7 @@ export uniform int width() { return programCount; }
 
 
 struct Foo {
-    float f[18];
+    float f[129];
 };
 
 struct Bar {
@@ -15,7 +15,7 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
     uniform Bar bar;
     for (uniform int i = 0; i < 6; ++i)
-        for (uniform int j = 0; j < 18; ++j)
+        for (uniform int j = 0; j < 129; ++j)
             bar.foo[i].f[j] = 2.+b-5;
 
     bar.foo[5].f[a] = a;

tests/pass-varying-lvalue-to-ref.ispc

@@ -4,8 +4,8 @@ export uniform int width() { return programCount; }
 void inc(uniform float * varying v) { ++(*v); }
 
 export void f_fu(uniform float ret[], uniform float aa[], uniform float b) {
-    uniform float foo[32];
-    for (uniform int i = 0; i < 32; ++i)
+    uniform float foo[2*programCount];
+    for (uniform int i = 0; i < 2*programCount; ++i)
         foo[i] = 10+i;
     int a = (int)aa[programIndex];
     inc(&foo[a]);

tests/phi-opts-1.ispc

@@ -3,8 +3,9 @@ export uniform int width() { return programCount; }
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float sum = 0;
-    for (int i = 0; i < 16; i += programCount)
-        sum += aFOO[i+programIndex];
+    for (int i = programIndex; i < 16; i += programCount) {
+        sum += aFOO[i];
+    }
     RET[programIndex] = reduce_add(sum); 
 }
 

tests/popcnt-1.ispc

@@ -8,11 +8,18 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     RET[programIndex] = popcnt((int)a);
 }
 
-export void result(uniform float RET[]) { 
-    uniform int pc[16] = { 1, 1, 2, 1,
-                           2, 2, 3, 1,
-                           2, 2, 3, 2, 
-                           3, 3, 4, 1 };
-    RET[programIndex] = pc[programIndex];
+static int manualpc(int v) {
+    int count = 0;
+    while (v != 0) {
+        if (v & 1)
+            ++count;
+        v >>= 1;
+    }
+    return count;
+}
+
+export void result(uniform float RET[]) { 
+    assert(programCount <= 64);
+    RET[programIndex] = manualpc(programIndex+1);
 }
 

tests/popcnt-2.ispc

@@ -18,9 +18,11 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     RET[programIndex] = popcnt(int4(0xf0f0f0f0, 0xff, 0x10, 0));
 }
 
-export void result(uniform float RET[]) { 
-    RET[0] = RET[4] = RET[8] = RET[12] = 16;
-    RET[1] = RET[5] = RET[9] = RET[13] = 8;
-    RET[2] = RET[6] = RET[10] = RET[14] = 1;
-    RET[3] = RET[7] = RET[11] = RET[15] = 0;
+export void result(uniform float RET[]) {
+    for (uniform int i = 0; i < programCount; i += 4) {
+        RET[i] = 16;
+        RET[i+1] = 8;
+        RET[i+2] = 1;
+        RET[i+3] = 0;
+    }
 }

tests/popcnt-3.ispc

@@ -3,9 +3,9 @@ export uniform int width() { return programCount; }
 
 
 
-export void f_f(uniform float RET[4], uniform float aFOO[]) {
+export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex];
     RET[programIndex] = popcnt(a < 3);
 }
 
-export void result(uniform float RET[]) { RET[programIndex] = programCount == 1 ? 1 : 2; }
+export void result(uniform float RET[]) { RET[programIndex] = (programCount == 1) ? 1 : 2; }

tests/typedef-2.ispc

@@ -19,7 +19,7 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     for (uniform int i = 0; i < 16; ++i)
         for (uniform int j = 0; j < 16; ++j)
             bar.foo[i].x[j] = b;
-    RET[programIndex] = bar.foo[a-1].x[a-1];
+    RET[programIndex] = bar.foo[min(15, a-1)].x[min(15, a-1)];
 }
 
 export void result(uniform float RET[]) { RET[programIndex] = 5; }

tests/varying-struct-3.ispc

@@ -15,7 +15,7 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     RET[programIndex] = g.x;
 }
 
-export void result(uniform float RET[4]) { 
+export void result(uniform float RET[]) { 
     RET[programIndex] = 15;
     RET[0] = RET[1] = 10;
 }

tests/varying-struct-6.ispc

@@ -18,4 +18,4 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     RET[programIndex] = bar.uf.x + bar.vf.y;
 }
 
-export void result(uniform float RET[4]) { RET[programIndex] = 6+programIndex; }
+export void result(uniform float RET[]) { RET[programIndex] = 6+programIndex; }