Initial commit.

tests/array-1.ispc

@@ -0,0 +1,14 @@
+
+export uniform int width() { return programCount; }
+
+
+
+static float x[2][1];
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    float a = aFOO[programIndex];
+    x[0][1] = a;
+    RET[programIndex] = x[0][1];
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 1+programIndex; }

tests/array-assignment-varying-control.ispc

@@ -0,0 +1,24 @@
+
+export uniform int width() { return programCount; }
+
+
+
+struct Foo { float f; };
+
+void f(reference uniform Foo foo[], float a) {
+    ++foo[a].f;
+}
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    float f[40] = a;
+    float g[40] = b;
+    if (a < 2)
+        f = g;
+    RET[programIndex] = f[a];
+}
+
+export void result(uniform float RET[]) { 
+    RET[programIndex] = 1+programIndex;
+    RET[0] = 5;
+}

tests/array-gather-ifs.ispc

@@ -0,0 +1,24 @@
+
+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 int i;
+    for (i = 0; i < 45; ++i)
+        x[i] = i;
+
+    float ret;
+    if ((int)a & 1)
+        ret = x[a-1];
+    else 
+        ret = x[a];
+    RET[programIndex] = ret;
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 2 * ((programIndex+1) / 2);
+}

tests/array-gather-multi-unif.ispc

@@ -0,0 +1,22 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    int a = aFOO[programIndex];
+    uniform float x[34][34];
+    // HACK to prevent the init from getting turned into a @llvm.memset
+    // intrinsic, which the JIT doesn't deal with...
+    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;
+    RET[programIndex] = x[4][4] + x[1][1] + x[b][b] + x[0][0];
+}
+
+export void result(uniform float RET[]) { 
+    if (programCount == 4)
+        RET[programIndex] = 5.; 
+    else
+        RET[programIndex] = 10.; 
+}

tests/array-gather-simple.ispc

@@ -0,0 +1,19 @@
+
+export uniform int width() { return programCount; }
+
+struct Foo { float f; };
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    float foo[5] = { 0, a, 0, 2 * a, 3 };
+    uniform int offset[4] = { 1,2,3,4 };
+    int x = offset[programIndex & 0x3];
+    RET[programIndex] = foo[x];
+}
+
+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;
+}

tests/array-gather-unif-runflags.ispc

@@ -0,0 +1,24 @@
+
+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 int i;
+    for (i = 0; i < 45; ++i)
+        x[i] = i+b;
+    a -= 1;
+    if (a == 3) a = 0;
+    a *= 10000000;
+    float ret = 1234;
+    if (a < 5)
+        ret = x[a];
+    RET[programIndex] = ret;
+}
+
+
+export void result(uniform float RET[4]) {
+    RET[programIndex] = 1234;
+    RET[0] = RET[3] = 5;
+}

tests/array-gather-unif.ispc

@@ -0,0 +1,17 @@
+
+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 int i;
+    for (i = 0; i < 45; ++i)
+        x[i] = i+b;
+    RET[programIndex] = x[a];
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 6+programIndex;
+}

tests/array-gather-vary.ispc

@@ -0,0 +1,17 @@
+
+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];
+    uniform int i;
+    for (i = 0; i < 45; ++i)
+        x[i] = a+b;
+    RET[programIndex] = x[a];
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 6 + programIndex;;
+}

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

@@ -0,0 +1,17 @@
+
+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] = 2.;
+    // all are 2 except (3,4) = 0, (1,4) = 1, (2,4) = 1, (4,4) = 1
+    if (a == 3.)
+        x[a][b-1] = 0;
+    else
+        x[a][b-1] = 1;
+    RET[programIndex] = x[3][a];
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 2; RET[3] = 0; }

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

@@ -0,0 +1,20 @@
+
+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] = 2.;
+    // all are 2 except (4,2) = 0, (4,...) = 1, (4,programCount-1)=2
+    if (a == 3.)
+        x[b-1][a-1] = 0;
+    else
+        x[b-1][a-1] = 1;
+    RET[programIndex] = x[4][a];
+}
+
+export void result(uniform float RET[]) { 
+    RET[programIndex] = 1;
+    RET[1] = 0;
+    RET[programCount-1] = 2;
+}

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

@@ -0,0 +1,17 @@
+
+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][74] = 2.;
+    x[a][b-1] = 0;
+    RET[programIndex] = x[2][a];
+}
+
+export void result(uniform float RET[]) { 
+    RET[programIndex] = 2;
+    RET[3] = 0;
+}
+

tests/array-multidim-gather-scatter.ispc

@@ -0,0 +1,18 @@
+
+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[40][40] = b;
+    uniform int index[4] = { 0, 1, 2, 4 };
+    float v = index[programIndex & 0x3];
+    x[a][v] = 0;
+    RET[programIndex] = x[v+1][v];
+}
+
+export void result(uniform float RET[]) { 
+    RET[programIndex] = 5;
+    RET[0] = RET[1] = RET[2] = 0;
+}
+

tests/array-multidim-gather.ispc

@@ -0,0 +1,21 @@
+
+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[4][3];
+    uniform int i, j;
+    for (i = 0; i < 4; ++i)
+        for (j = 0; j < 3; ++j)
+            x[i][j] = 3*i+j;
+
+    a = clamp(a-2., 0., 2.);
+    RET[programIndex] = x[a][a];
+}
+
+export void result(uniform float RET[]) { 
+    RET[programIndex] = 8;
+    RET[0] = RET[1] = 0;
+    RET[2] = 4;
+}

tests/array-scatter-unif-2.ispc

@@ -0,0 +1,17 @@
+
+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)
+        x[i] = 0;
+    
+    x[2*(a-1)] = b;
+    RET[programIndex] = x[4]+x[5];
+}
+
+    
+export void result(uniform float RET[]) { RET[programIndex] = 5; }

tests/array-scatter-unif-3.ispc

@@ -0,0 +1,17 @@
+
+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)
+        x[i] = 0;
+
+    x[2*(a-1)] = b;
+    RET[programIndex] = x[2*(a-1)];
+}
+
+    
+export void result(uniform float RET[]) { RET[programIndex] = 5; }

tests/array-scatter-unif.ispc

@@ -0,0 +1,20 @@
+
+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] = 0;
+    x[a] = 2;
+    RET[programIndex] = x[4] + x[0] + x[5];
+}
+
+    
+export void result(uniform float RET[]) { 
+    if (programCount == 4)
+        RET[programIndex] = 2;
+    else
+        RET[programIndex] = 4;
+}
+

tests/array-scatter-vary.ispc

@@ -0,0 +1,20 @@
+
+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)
+        x[i] = 0;
+    x[a] = a;
+    RET[programIndex] = x[4] + x[0] + x[5];
+}
+
+    
+export void result(uniform float RET[4]) { 
+    RET[programIndex] = 0;
+    RET[3] = 4;
+    RET[4] = 5;
+}

tests/array-struct-gather.ispc

@@ -0,0 +1,26 @@
+
+export uniform int width() { return programCount; }
+
+
+
+struct Foo {
+    uniform float x[17];
+};
+
+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)
+        foo.x[i] = i;
+
+    if ((int)a & 1)
+        { RET[programIndex] = foo.x[a-1]; return; }
+    else 
+        { RET[programIndex] = foo.x[a]; return; }
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = ((programIndex+1) / 2) * 2;
+}

tests/array.ispc

@@ -0,0 +1,24 @@
+
+export uniform int width() { return programCount; }
+
+
+
+void foo(float a[]) {
+    a[5] = 0;
+}
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    float x[10];
+    uniform int i;
+    for (i = 0; i < 10; ++i)
+        x[i] = a*b;
+    if (a >= 2)
+        foo(x);
+    RET[programIndex] = x[b] + x[9];
+}
+
+export void result(uniform float RET[]) { 
+    RET[programIndex] = 5 * (programIndex+1);
+    RET[0] = RET[1] = 10;
+}

tests/bitnot.ispc

@@ -0,0 +1,12 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_v(uniform float RET[]) {
+    unsigned int x = 0xffff0f0f;
+    RET[programIndex] = ~x;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 0xf0f0;
+}

tests/bool-float-typeconv.ispc

@@ -0,0 +1,10 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    float a = aFOO[programIndex];
+    RET[programIndex] = a < 3.;
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 0; RET[0] = RET[1] = 1; }

tests/c-cif-nested-continue.ispc

@@ -0,0 +1,21 @@
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    float a = aFOO[programIndex];
+    int i, j;
+    float r = 0;
+    for (i = 0; i < a; ++i) {
+        cif (i != 0) {
+            cif (a != 2)
+                ccontinue;
+            r = 10;
+        }
+        ++r;
+    }
+    RET[programIndex] = r;
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 1; RET[1] = 11; }

tests/c-do-2.ispc

@@ -0,0 +1,17 @@
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_v(uniform float RET[]) {
+    int i=0, j=0;
+    do {
+        ++j;
+        if (i >= 5) ccontinue;
+        ++j;
+        } while (++i < 10);
+    RET[programIndex] = (float)j;
+}
+
+
+export void result(uniform float RET[]) { RET[programIndex] = 15; }

tests/c-do-3.ispc

@@ -0,0 +1,17 @@
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_v(uniform float RET[]) {
+    int i=0, j=0;
+    do {
+        ++j;
+        if (i >= 5) cbreak;
+        ++j;
+        } while (++i < 10);
+    RET[programIndex] = j;
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 11; }
+

tests/c-for-loop-nested-continues.ispc

@@ -0,0 +1,22 @@
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    float a = aFOO[programIndex];
+    int i, j;
+    float r = 0;
+    for (i = 0; i < a+1; ++i) {
+        if (i == 1)
+            ccontinue;
+        for (j = 0; j < a; ++j) {
+            if (a == 2)
+                ccontinue;
+        }
+        ++r;
+    }
+    RET[programIndex] = r;
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 1+programIndex; }

tests/c-for-unif-test-vary-break.ispc

@@ -0,0 +1,18 @@
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    uniform int x;
+    float aa = a;
+    for (x = 0; x < 99999; ++x) {
+        if (x == a) cbreak;
+        ++aa;
+    }
+    RET[programIndex] = aa;
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 2+2*programIndex; }
+

tests/c-test-108.ispc

@@ -0,0 +1,19 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    int i, j=0;
+    for (i=a; i < 10; ++i) {
+        j += sqrt((a / 3.f) * (1.f / (i+2)));
+        if (i >= 5) ccontinue;
+        j += sqrt(((a+2) / 3.f) * (1.f / (i+3)));
+    }
+    RET[programIndex] = (float)j; 
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 0;
+}

tests/c-test-131.ispc

@@ -0,0 +1,19 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    int i, j=0;
+    for (i=a; i < 10; ++i) {
+        j += sqrt((a / 3.f) * (1.f / (i+2)));
+        cif (i >= 5) ccontinue;
+        j += sqrt(((a+2) / 3.f) * (1.f / (i+3)));
+    }
+    RET[programIndex] = (float)j; 
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 0;
+}

tests/c-test-133.ispc

@@ -0,0 +1,18 @@
+
+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 i;
+    for (i = 0; i < b; ++i) {
+        cif (i+2 == b) ccontinue;
+        ++a;
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 5+programIndex;
+}

tests/c-test-134.ispc

@@ -0,0 +1,23 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    float i, j;
+    for (i = 0; i < b; ++i) {
+        cif (a == 1.) cbreak;
+        for (j = 0; j < b; ++j) {
+            if (a == 3.) cbreak;
+            ++a;
+        }
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 26+programIndex;
+    RET[0] = 1;
+    RET[1] = RET[2] = 3;
+}

tests/c-test-135.ispc

@@ -0,0 +1,23 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    float i, j;
+    for (i = 0; i < b; ++i) {
+        if (a == 1.) cbreak;
+        for (j = 0; j < b; ++j) {
+            cif (a == 3.) cbreak;
+            ++a;
+        }
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 26+programIndex;
+    RET[0] = 1;
+    RET[1] = RET[2] = 3;
+}

tests/c-test-136.ispc

@@ -0,0 +1,23 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    float i, j;
+    for (i = 0; i < b; ++i) {
+        cif (a == 1.) cbreak;
+        for (j = 0; j < b; ++j) {
+            cif (a == 3.) cbreak;
+            ++a;
+        }
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 26+programIndex;
+    RET[0] = 1;
+    RET[1] = RET[2] = 3;
+}

tests/c-test-62.ispc

@@ -0,0 +1,18 @@
+
+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 i;
+    for (i = 0; i < b; ++i) {
+        if (i == 2) cbreak;
+        ++a;
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 3+programIndex;
+}

tests/c-test-63.ispc

@@ -0,0 +1,18 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    float i;
+    for (i = 0; i < b; ++i) {
+        if (i == 2) cbreak;
+        ++a;
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 3+programIndex;
+}

tests/c-test-64.ispc

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

tests/c-test-65.ispc

@@ -0,0 +1,23 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[4], uniform float aFOO[4], uniform float b) {
+    float a = aFOO[programIndex&0x3];
+    float i, j;
+    for (i = 0; i < b; ++i) {
+        if (a == 1.) cbreak;
+        for (j = 0; j < b; ++j) {
+            if (a == 3.) cbreak;
+            ++a;
+        }
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 3;
+    RET[0] = RET[4] = RET[8] = RET[12] = 1;
+    RET[3] = RET[7] = RET[11] = RET[15] = 29;
+}

tests/c-test-66.ispc

@@ -0,0 +1,24 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex&0x3];
+    float i, j;
+    for (i = 0; i < b; ++i) {
+        ++a;
+        for (j = 0; j < b; ++j) {
+            if (a == 3.) cbreak;
+            ++a;
+        }
+        ++a;
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 32;
+    RET[2] = RET[6] = RET[10] = RET[14] = 38;
+    RET[3] = RET[7] = RET[11] = RET[15] = 39;
+}

tests/c-test-67.ispc

@@ -0,0 +1,18 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    float i, j;
+    for (i = 0; i < b; ++i) {
+        if (a == b) ccontinue;
+        ++a;
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = programIndex < 5 ? 5 : 6+programIndex;
+}

tests/c-test-68.ispc

@@ -0,0 +1,21 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    float i, j;
+    for (i = 0; i < b; ++i) {
+        if (a == b) ccontinue;
+        ++a;
+        if (a == 2) cbreak;
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 5;
+    if (programIndex >= 5) RET[programIndex] = 6 + programIndex;
+    RET[0] = 2;
+}

tests/c-test-69.ispc

@@ -0,0 +1,22 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    float i, j;
+    for (i = 0; i < b; ++i) {
+        if (a == b) 
+            a += 10;
+        ++a;
+        if (a == 2) cbreak;
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 16+programIndex;
+    if (programIndex >= 5) RET[programIndex] = 6+programIndex;
+    RET[0] = 2;
+}

tests/c-test-70.ispc

@@ -0,0 +1,26 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    float i, j;
+    if (a >= 4)
+        a = 0;
+    else {
+        for (i = 0; i < b; ++i) {
+            if (a == b) 
+                a += 10;
+            ++a;
+            if (a == 2) cbreak;
+        }
+    }
+    RET[programIndex] = a;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 0;
+    RET[0] = 2;
+    RET[1] = 17;
+    RET[2] = 18;
+}

tests/c-test-71.ispc

@@ -0,0 +1,26 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    float i, r = a;
+    if (a >= 4)
+        { RET[programIndex] = 0; return; }
+    else {
+        for (i = 0; i < a; ++i) {
+            if (r == b) 
+                r += 10;
+            ++r;
+            if (r == 2) cbreak;
+        }
+    }
+    RET[programIndex] = r;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 0;
+    RET[0]= 2;
+    RET[1] = 4;
+    RET[2] = 16;
+}

tests/c-test-76.ispc

@@ -0,0 +1,18 @@
+
+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 i;
+    for (i = 0; i < b; ++i) {
+        if (i+2 == b) ccontinue;
+        ++a;
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 5+programIndex;
+}

tests/c-test-77.ispc

@@ -0,0 +1,18 @@
+
+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 i;
+    for (i = 0; i < b; ++i) {
+        ++a;
+        if (i+2 == b) cbreak;
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 5+programIndex;
+}

tests/c-test-78.ispc

@@ -0,0 +1,14 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_v(uniform float RET[]) {
+int i;
+for (i = 0; i < 10; ++i) {
+  if (i == 5) cbreak;
+}
+RET[programIndex] = (float)i; }
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 5.000000;
+}

tests/c-test-79.ispc

@@ -0,0 +1,14 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_v(uniform float RET[]) {
+int i, j=0;
+for (i = 0; i < 10; ++i) {
+  if (i >= 5) ccontinue;
+  ++j;}
+RET[programIndex] = (float)j; }
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 5.000000;
+}

tests/c-test-80.ispc

@@ -0,0 +1,15 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_v(uniform float RET[]) {
+int i=0, j=0;
+while (i++ < 10) {
+  ++j;
+  if (i >= 5) ccontinue;
+  ++j;}
+RET[programIndex] = (float)j; }
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 14.000000;
+}

tests/c-test-81.ispc

@@ -0,0 +1,15 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_v(uniform float RET[]) {
+int i=0, j=0;
+while (i++ < 10) {
+  ++j;
+  if (i >= 5) cbreak;
+  ++j;}
+RET[programIndex] = (float)j; }
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 9.000000;
+}

tests/cfor-array-gather-ifs.ispc

@@ -0,0 +1,24 @@
+
+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 int i;
+    cfor (i = 0; i < 45; ++i)
+        x[i] = i;
+
+    float ret;
+    if ((int)a & 1)
+        ret = x[a-1];
+    else 
+        ret = x[a];
+    RET[programIndex] = ret;
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 2 * ((programIndex+1) / 2);
+}

tests/cfor-array-gather-unif-runflags.ispc

@@ -0,0 +1,24 @@
+
+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 int i;
+    cfor (i = 0; i < 45; ++i)
+        x[i] = i+b;
+    a -= 1;
+    if (a == 3) a = 0;
+    a *= 10000000;
+    float ret = 1234;
+    if (a < 5)
+        ret = x[a];
+    RET[programIndex] = ret;
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 1234;
+    RET[0] = RET[3] = 5;
+}

tests/cfor-array-gather-unif.ispc

@@ -0,0 +1,17 @@
+
+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 int i;
+    cfor (i = 0; i < 45; ++i)
+        x[i] = i+b;
+    RET[programIndex] = x[a];
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 6+programIndex;
+}

tests/cfor-array-gather-vary.ispc

@@ -0,0 +1,17 @@
+
+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];
+    uniform int i;
+    cfor (i = 0; i < 45; ++i)
+        x[i] = a+b;
+    RET[programIndex] = x[a];
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 6 + programIndex;;
+}

tests/cfor-array-multidim-gather.ispc

@@ -0,0 +1,21 @@
+
+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[4][3];
+    uniform int i, j;
+    cfor (i = 0; i < 4; ++i)
+        cfor (j = 0; j < 3; ++j)
+            x[i][j] = 3*i+j;
+
+    a = clamp(a-2., 0., 2.);
+    RET[programIndex] = x[a][a];
+}
+
+export void result(uniform float RET[]) { 
+    RET[programIndex] = 8;
+    RET[0] = RET[1] = 0;
+    RET[2] = 4;
+}

tests/cfor-array-struct-gather.ispc

@@ -0,0 +1,26 @@
+
+export uniform int width() { return programCount; }
+
+
+
+struct Foo {
+    uniform float x[17];
+};
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    uniform Foo foo;
+    uniform int i;
+    cfor (i = 0; i < 17; ++i)
+        foo.x[i] = i;
+
+    if ((int)a & 1)
+        { RET[programIndex] = foo.x[a-1]; return; }
+    else 
+        { RET[programIndex] = foo.x[a]; return; }
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = ((programIndex+1) / 2) * 2;
+}

tests/cfor-array.ispc

@@ -0,0 +1,24 @@
+
+export uniform int width() { return programCount; }
+
+
+
+void foo(float a[]) {
+    a[5] = 0;
+}
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    float x[10];
+    uniform int i;
+    cfor (i = 0; i < 10; ++i)
+        x[i] = a*b;
+    if (a >= 2)
+        foo(x);
+    RET[programIndex] = x[b] + x[9];
+}
+
+export void result(uniform float RET[]) { 
+    RET[programIndex] = 5 * (programIndex+1);
+    RET[0] = RET[1] = 10;
+}

tests/cfor-c-cif-nested-continue.ispc

@@ -0,0 +1,35 @@
+static float float4(uniform float a, uniform float b, uniform float c, 
+                    uniform float d) {
+    float ret = 0;
+    cfor (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    float a = aFOO[programIndex&0x3];
+    int i, j;
+    float r = 0;
+    cfor (i = 0; i < a; ++i) {
+        cif (i != 0) {
+            cif (a != 2)
+                ccontinue;
+            r = 10;
+        }
+        ++r;
+    }
+    RET[programIndex] = r;
+}
+
+export void result(uniform float RET[]) { 
+    uniform float ret[4] = { 1,11,1,1 };
+    RET[programIndex] = ret[programIndex & 0x3];
+}

tests/cfor-c-for-loop-nested-continues.ispc

@@ -0,0 +1,36 @@
+static float float4(uniform float a, uniform float b, uniform float c, 
+                    uniform float d) {
+    float ret = 0;
+    cfor (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    float a = aFOO[programIndex&0x3];
+    int i, j;
+    float r = 0;
+    cfor (i = 0; i < a+1; ++i) {
+        if (i == 1)
+            ccontinue;
+        cfor (j = 0; j < a; ++j) {
+            if (a == 2)
+                ccontinue;
+        }
+        ++r;
+    }
+    RET[programIndex] = r;
+}
+
+export void result(uniform float RET[]) { 
+    uniform float ret[4] = { 1,2,3,4 };
+    RET[programIndex] = ret[programIndex & 0x3];
+}

tests/cfor-c-for-unif-test-vary-break.ispc

@@ -0,0 +1,31 @@
+static float float4(uniform float a, uniform float b, uniform float c, 
+                    uniform float d) {
+    float ret = 0;
+    cfor (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex&0x3];
+    uniform int x;
+    float aa = a;
+    cfor (x = 0; x < 99999; ++x) {
+        if (x == a) cbreak;
+        ++aa;
+    }
+    RET[programIndex] = aa;
+}
+
+export void result(uniform float RET[]) { 
+    uniform float ret[4] = { 2,4,6,8 };
+    RET[programIndex] = ret[programIndex & 0x3];
+}

tests/cfor-c-test-108.ispc

@@ -0,0 +1,19 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex&0x3];
+    int i, j=0;
+    cfor (i=a; i < 10; ++i) {
+        j += sqrt((a / 3.f) * (1.f / (i+2)));
+        if (i >= 5) ccontinue;
+        j += sqrt(((a+2) / 3.f) * (1.f / (i+3)));
+    }
+    RET[programIndex] = (float)j; 
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 0;
+}

tests/cfor-c-test-131.ispc

@@ -0,0 +1,19 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex&0x3];
+    int i, j=0;
+    cfor (i=a; i < 10; ++i) {
+        j += sqrt((a / 3.f) * (1.f / (i+2)));
+        cif (i >= 5) ccontinue;
+        j += sqrt(((a+2) / 3.f) * (1.f / (i+3)));
+    }
+    RET[programIndex] = (float)j; 
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 0;
+}

tests/cfor-c-test-133.ispc

@@ -0,0 +1,19 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex&0x3];
+    uniform float i;
+    cfor (i = 0; i < b; ++i) {
+        cif (i+2 == b) ccontinue;
+        ++a;
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    uniform float ret[4] = { 5,6,7,8 };
+    RET[programIndex] = ret[programIndex & 0x3];
+}

tests/cfor-c-test-134.ispc

@@ -0,0 +1,22 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex&0x3];
+    float i, j;
+    cfor (i = 0; i < b; ++i) {
+        cif (a == 1.) cbreak;
+        cfor (j = 0; j < b; ++j) {
+            if (a == 3.) cbreak;
+            ++a;
+        }
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    uniform float ret[4] = { 1,3,3,29 };
+    RET[programIndex] = ret[programIndex & 0x3];
+}

tests/cfor-c-test-135.ispc

@@ -0,0 +1,22 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[4], uniform float aFOO[4], uniform float b) {
+    float a = aFOO[programIndex&0x3];
+    float i, j;
+    cfor (i = 0; i < b; ++i) {
+        if (a == 1.) cbreak;
+        cfor (j = 0; j < b; ++j) {
+            cif (a == 3.) cbreak;
+            ++a;
+        }
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[4]) {
+    uniform float ret[4] = { 1,3,3,29 };
+    RET[programIndex] = ret[programIndex & 0x3];
+}

tests/cfor-c-test-136.ispc

@@ -0,0 +1,22 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[4], uniform float aFOO[4], uniform float b) {
+    float a = aFOO[programIndex&0x3];
+    float i, j;
+    cfor (i = 0; i < b; ++i) {
+        cif (a == 1.) cbreak;
+        cfor (j = 0; j < b; ++j) {
+            cif (a == 3.) cbreak;
+            ++a;
+        }
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[4]) {
+    uniform float ret[4] = { 1,3,3,29 };
+    RET[programIndex] = ret[programIndex & 0x3];
+}

tests/cfor-c-test-62.ispc

@@ -0,0 +1,19 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex&0x3];
+    uniform float i;
+    cfor (i = 0; i < b; ++i) {
+        if (i == 2) cbreak;
+        ++a;
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    uniform float ret[4] = { 3, 4, 5, 6 };
+    RET[programIndex] = ret[programIndex & 0x3];
+}

tests/cfor-c-test-63.ispc

@@ -0,0 +1,19 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex&0x3];
+    float i;
+    cfor (i = 0; i < b; ++i) {
+        if (i == 2) cbreak;
+        ++a;
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    uniform float ret[4] = { 3, 4, 5, 6 };
+    RET[programIndex] = ret[programIndex & 0x3];
+}

tests/cfor-c-test-64.ispc

@@ -0,0 +1,24 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex&0x3];
+    float i;
+    if (a < 3) {
+        ++a;
+    }
+    else {
+        cfor (i = 0; i < b; ++i) {
+            if (i == 2) cbreak;
+            ++a;
+        }
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    uniform float ret[4] = { 2, 3, 5, 6 };
+    RET[programIndex] = ret[programIndex & 0x3];
+}

tests/cfor-c-test-65.ispc

@@ -0,0 +1,22 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex&0x3];
+    float i, j;
+    cfor (i = 0; i < b; ++i) {
+        if (a == 1.) cbreak;
+        cfor (j = 0; j < b; ++j) {
+            if (a == 3.) cbreak;
+            ++a;
+        }
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    uniform float ret[4] = { 1, 3, 3, 29 };
+    RET[programIndex] = ret[programIndex & 0x3];
+}

tests/cfor-c-test-66.ispc

@@ -0,0 +1,23 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex&0x3];
+    float i, j;
+    cfor (i = 0; i < b; ++i) {
+        ++a;
+        cfor (j = 0; j < b; ++j) {
+            if (a == 3.) cbreak;
+            ++a;
+        }
+        ++a;
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    uniform float ret[4] = { 32, 32, 38, 39 };
+    RET[programIndex] = ret[programIndex & 0x3];
+}

tests/cfor-c-test-67.ispc

@@ -0,0 +1,18 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex&0x3];
+    float i, j;
+    cfor (i = 0; i < b; ++i) {
+        if (a == b) ccontinue;
+        ++a;
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 5;
+}

tests/cfor-c-test-68.ispc

@@ -0,0 +1,20 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex&0x3];
+    float i, j;
+    cfor (i = 0; i < b; ++i) {
+        if (a == b) ccontinue;
+        ++a;
+        if (a == 2) cbreak;
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    uniform float ret[4] = { 2, 5, 5, 5 };
+    RET[programIndex] = ret[programIndex & 0x3];
+}

tests/cfor-c-test-69.ispc

@@ -0,0 +1,21 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex&0x3];
+    float i, j;
+    cfor (i = 0; i < b; ++i) {
+        if (a == b) 
+            a += 10;
+        ++a;
+        if (a == 2) cbreak;
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    uniform float ret[4] = { 2, 17, 18, 19 };
+    RET[programIndex] = ret[programIndex & 0x3];
+}

tests/cfor-c-test-70.ispc

@@ -0,0 +1,24 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex&0x3];
+    float i, j;
+    if (a >= 4)
+        a = 0;
+    else {
+        cfor (i = 0; i < b; ++i) {
+            if (a == b) 
+                a += 10;
+            ++a;
+            if (a == 2) cbreak;
+        }
+    }
+    RET[programIndex] = a;
+}
+
+export void result(uniform float RET[]) {
+    uniform float ret[4] = { 2,17,18,0 };
+    RET[programIndex] = ret[programIndex & 0x3];
+}

tests/cfor-c-test-71.ispc

@@ -0,0 +1,24 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex&0x3];
+    float i, r = a;
+    if (a >= 4)
+        { RET[programIndex] = 0; return; }
+    else {
+        cfor (i = 0; i < a; ++i) {
+            if (r == b) 
+                r += 10;
+            ++r;
+            if (r == 2) cbreak;
+        }
+    }
+    RET[programIndex] = r;
+}
+
+export void result(uniform float RET[]) {
+    uniform float ret[4] = { 2,4,16,0 };
+    RET[programIndex] = ret[programIndex & 0x3];
+}

tests/cfor-c-test-76.ispc

@@ -0,0 +1,19 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex&0x3];
+    uniform float i;
+    cfor (i = 0; i < b; ++i) {
+        if (i+2 == b) ccontinue;
+        ++a;
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    uniform float ret[4] = { 5,6,7,8 };
+    RET[programIndex] = ret[programIndex & 0x3];
+}

tests/cfor-c-test-77.ispc

@@ -0,0 +1,19 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex&0x3];
+    uniform float i;
+    cfor (i = 0; i < b; ++i) {
+        ++a;
+        if (i+2 == b) cbreak;
+    }
+    RET[programIndex] = a;
+}
+
+
+export void result(uniform float RET[]) {
+    uniform float ret[4] = { 5,6,7,8 };
+    RET[programIndex] = ret[programIndex & 0x3];
+}

tests/cfor-c-test-78.ispc

@@ -0,0 +1,14 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_v(uniform float RET[]) {
+int i;
+cfor (i = 0; i < 10; ++i) {
+  if (i == 5) cbreak;
+}
+RET[programIndex] = (float)i; }
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 5.000000;
+}

tests/cfor-c-test-79.ispc

@@ -0,0 +1,15 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_v(uniform float RET[]) {
+int i, j=0;
+cfor (i = 0; i < 10; ++i) {
+  if (i >= 5) ccontinue;
+  ++j;}
+RET[programIndex] = (float)j; 
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 5.000000;
+}

tests/cfor-cif-nested-continue.ispc

@@ -0,0 +1,35 @@
+static float float4(uniform float a, uniform float b, uniform float c, 
+                    uniform float d) {
+    float ret = 0;
+    cfor (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    float a = aFOO[programIndex&0x3];
+    int i, j;
+    float r = 0;
+    cfor (i = 0; i < a; ++i) {
+        cif (i != 0) {
+            cif (a != 2)
+                continue;
+            r = 10;
+        }
+        ++r;
+    }
+    RET[programIndex] = r;
+}
+
+export void result(uniform float RET[]) { 
+    uniform float ret[4] = { 1,11,1,1 };
+    RET[programIndex] = ret[programIndex & 0x3];
+}

tests/cfor-const-fold-4.ispc

@@ -0,0 +1,19 @@
+
+export uniform int width() { return programCount; }
+
+
+
+#define N(x)  (3*x+1)
+// p a power of 2
+#define ROUND_UP(x, p) ((x + (p-1)) & ~(p-1))
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    float a = aFOO[programIndex&0x3];
+    uniform float x[ROUND_UP(N(3), 16)];
+    uniform int i;
+    cfor (i = 0; i < ROUND_UP(N(3), 16); ++i)
+        x[i] = i * i;
+    RET[programIndex] = x[4];
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 16.; }

tests/cfor-for-loop-nested-continues.ispc

@@ -0,0 +1,21 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    float a = aFOO[programIndex];
+    int i, j;
+    float r = 0;
+    cfor (i = 0; i < a+1; ++i) {
+        if (i == 1)
+            continue;
+        cfor (j = 0; j < a; ++j) {
+            if (a == 2)
+                continue;
+        }
+        ++r;
+    }
+    RET[programIndex] = r;
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 1+programIndex; }

tests/cfor-for-unif-test-vary-break.ispc

@@ -0,0 +1,16 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    uniform int x;
+    float aa = a;
+    cfor (x = 0; x < 99999; ++x) {
+        if (x == a) break;
+        ++aa;
+    }
+    RET[programIndex] = aa;
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 2 + 2*programIndex; }

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

@@ -0,0 +1,16 @@
+
+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];
+    cfor (uniform int i = 0; i < 25; ++i)
+        cfor (uniform int j = 0; j < 25; ++j)
+            udx[i][j] = 10*i+j;
+
+    int x = 1;
+    RET[programIndex] = udx[x][programIndex+1];
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 11+programIndex; }

tests/cfor-gs-double-improve-multidim-2.ispc

@@ -0,0 +1,16 @@
+
+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[5][5];
+    cfor (uniform int i = 0; i < 5; ++i)
+        cfor (uniform int j = 0; j < 5; ++j)
+            udx[i][j] = 10*i+j;
+
+    int x = 1;
+    RET[programIndex] = udx[x][(int)b-2];
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 13; } 

tests/cfor-gs-double-improve-multidim-3.ispc

@@ -0,0 +1,16 @@
+
+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[5][5];
+    cfor (uniform int i = 0; i < 5; ++i)
+        cfor (uniform int j = 0; j < 5; ++j)
+            udx[i][j] = 10*i+j;
+
+    int x = 1;
+    RET[programIndex] = udx[b-4][x];
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 11; }

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

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

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

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

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

@@ -0,0 +1,16 @@
+
+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[5][5];
+    cfor (uniform int i = 0; i < 5; ++i)
+        cfor (uniform int j = 0; j < 5; ++j)
+            udx[i][j] = 10*i+j;
+
+    int x = 1;
+    RET[programIndex] = udx[x][x];
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 11; }

tests/cfor-gs-double-improve-varying-1.ispc

@@ -0,0 +1,15 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex]; 
+    double udx[5];
+    cfor (uniform int i = 0; i < 5; ++i)
+        udx[i] = i + a;
+
+    int x = b-4;
+    RET[programIndex] = udx[x];
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 2+programIndex; }

tests/cfor-gs-double-improve-varying.ispc

@@ -0,0 +1,15 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex]; 
+    double udx[5];
+    cfor (uniform int i = 0; i < 5; ++i)
+        udx[i] = i + a;
+
+    int x = 1;
+    RET[programIndex] = udx[x];
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 2+programIndex; }

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

@@ -0,0 +1,19 @@
+
+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];
+    cfor (uniform int i = 0; i < 20; ++i)
+        cfor (uniform int j = 0; j < 20; ++j)
+            udx[i][j] = 100*i+j;
+
+    int x = 1;
+    RET[programIndex] = udx[x][programIndex+1];
+}
+
+export void result(uniform float RET[]) { 
+    RET[programIndex] = 101+programIndex;
+}

tests/cfor-gs-improve-multidim-2.ispc

@@ -0,0 +1,16 @@
+
+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[5][5];
+    cfor (uniform int i = 0; i < 5; ++i)
+        cfor (uniform int j = 0; j < 5; ++j)
+            udx[i][j] = 10*i+j;
+
+    int x = 1;
+    RET[programIndex] = udx[x][(int)b-2];
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 13; } 

tests/cfor-gs-improve-multidim-3.ispc

@@ -0,0 +1,17 @@
+
+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[5][5];
+    cfor (uniform int i = 0; i < 5; ++i)
+        cfor (uniform int j = 0; j < 5; ++j)
+            udx[i][j] = 10*i+j;
+
+    int x = 1;
+    RET[programIndex] = udx[b-4][x];
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 11; }

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

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

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

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

tests/cfor-gs-improve-multidim.ispc

@@ -0,0 +1,17 @@
+
+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[18][18];
+    cfor (uniform int i = 0; i < 18; ++i)
+        cfor (uniform int j = 0; j < 18; ++j)
+            udx[i][j] = 100*i+j;
+
+    int x = 1;
+    RET[programIndex] = udx[x][x];
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 101; }

tests/cfor-gs-improve-varying-1.ispc

@@ -0,0 +1,15 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex]; 
+    float udx[5];
+    cfor (uniform int i = 0; i < 5; ++i)
+        udx[i] = i + a;
+
+    int x = b-4;
+    RET[programIndex] = udx[x];
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 2+programIndex; }

tests/cfor-gs-improve-varying.ispc

@@ -0,0 +1,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 udx[5];
+    cfor (uniform int i = 0; i < 5; ++i)
+        udx[i] = i + a;
+
+    int x = 1;
+    RET[programIndex] = udx[x];
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 2+programIndex; }

tests/cfor-ref-5.ispc

@@ -0,0 +1,20 @@
+
+export uniform int width() { return programCount; }
+
+
+
+void foo(reference float a) {
+    a = 0;
+}
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    float x[10];
+    uniform int i;
+    cfor (i = 0; i < 10; ++i)
+        x[i] = a*b;
+    foo(x[b]);
+    RET[programIndex] = x[5] + x[9];
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 5 * (programIndex+1); }

tests/cfor-ref-6.ispc

@@ -0,0 +1,26 @@
+
+export uniform int width() { return programCount; }
+
+
+
+void foo(reference float a[10]) {
+    a[5] = 0;
+}
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    float x[10];
+    uniform int i;
+    cfor (i = 0; i < 10; ++i)
+        x[i] = a*b;
+    if (a >= 2)
+        foo(x);
+    RET[programIndex] = x[b] + x[9];
+}
+
+export void result(uniform float RET[]) { 
+    RET[programIndex] = 5 * (programIndex+1);
+    RET[0] = 10;
+    RET[1] = 10;
+}
+