glsl-array-bounds: set out-of-bounds array index inside shader

[piglit.git] / tests / shaders / glsl-fs-inline-explosion.shader_test

// if you inline all functions indiscriminately, you won't pass this
[require]
GLSL >= 1.10
rlimit 268435456

[vertex shader]
void main()
{
        gl_Position = gl_Vertex;
        gl_TexCoord[0] = gl_Position;
}

[fragment shader]
void f64()
{
// use something that cannot be optimized away
        gl_FragColor = exp(gl_FragColor);
}


void f63()
{
        f64();
        f64();
}

void f62()
{
        f63();
        f63();
}

void f61()
{
        f62();
        f62();
}

void f60()
{
        f61();
        f61();
}

void f59()
{
        f60();
        f60();
}

void f58()
{
        f59();
        f59();
}

void f57()
{
        f58();
        f58();
}

void f56()
{
        f57();
        f57();
}

void f55()
{
        f56();
        f56();
}

void f54()
{
        f55();
        f55();
}

void f53()
{
        f54();
        f54();
}

void f52()
{
        f53();
        f53();
}

void f51()
{
        f52();
        f52();
}

void f50()
{
        f51();
        f51();
}

void f49()
{
        f50();
        f50();
}

void f48()
{
        f49();
        f49();
}

void f47()
{
        f48();
        f48();
}

void f46()
{
        f47();
        f47();
}

void f45()
{
        f46();
        f46();
}

void f44()
{
        f45();
        f45();
}

void f43()
{
        f44();
        f44();
}

void f42()
{
        f43();
        f43();
}

void f41()
{
        f42();
        f42();
}

void f40()
{
        f41();
        f41();
}

void f39()
{
        f40();
        f40();
}

void f38()
{
        f39();
        f39();
}

void f37()
{
        f38();
        f38();
}

void f36()
{
        f37();
        f37();
}

void f35()
{
        f36();
        f36();
}

void f34()
{
        f35();
        f35();
}

void f33()
{
        f34();
        f34();
}

void f32()
{
        f33();
        f33();
}

void f31()
{
        f32();
        f32();
}

void f30()
{
        f31();
        f31();
}

void f29()
{
        f30();
        f30();
}

void f28()
{
        f29();
        f29();
}

void f27()
{
        f28();
        f28();
}

void f26()
{
        f27();
        f27();
}

void f25()
{
        f26();
        f26();
}

void f24()
{
        f25();
        f25();
}

void f23()
{
        f24();
        f24();
}

void f22()
{
        f23();
        f23();
}

void f21()
{
        f22();
        f22();
}

void f20()
{
        f21();
        f21();
}

void f19()
{
        f20();
        f20();
}

void f18()
{
        f19();
        f19();
}

void f17()
{
        f18();
        f18();
}

void f16()
{
        f17();
        f17();
}

void f15()
{
        f16();
        f16();
}

void f14()
{
        f15();
        f15();
}

void f13()
{
        f14();
        f14();
}

void f12()
{
        f13();
        f13();
}

void f11()
{
        f12();
        f12();
}

void f10()
{
        f11();
        f11();
}

void f9()
{
        f10();
        f10();
}

void f8()
{
        f9();
        f9();
}

void f7()
{
        f8();
        f8();
}

void f6()
{
        f7();
        f7();
}

void f5()
{
        f6();
        f6();
}

void f4()
{
        f5();
        f5();
}

void f3()
{
        f4();
        f4();
}

void f2()
{
        f3();
        f3();
}

void f1()
{
        f2();
        f2();
}

void f0()
{
        f1();
        f1();
}

void main()
{
        gl_FragColor = vec4(0.1, 0.2, 0.3, 0.4);
        if(gl_TexCoord[0].x > 2.0) // this branch is never taken, but the compiler doesn't know this
                f0();
}

[test]
draw rect -1 -1 2 2
probe all rgba 0.1 0.2 0.3 0.4