glslang/Test/310.comp

#version 310 es

layout(local_size_x = 2) in;
layout(local_size_x = 16) in;     // ERROR, changing
layout(local_size_z = 4096) in;   // ERROR, too large
layout(local_size_x = 2) in;

const int total = gl_MaxComputeWorkGroupCount.y 
                + gl_MaxComputeUniformComponents
                + gl_MaxComputeTextureImageUnits
                + gl_MaxComputeImageUniforms
                + gl_MaxComputeAtomicCounters
                + gl_MaxComputeAtomicCounterBuffers;

buffer ShaderStorageBlock
{
    int value;
    float values[];
};

buffer InvalidShaderStorageBlock
{
    float values[];  // ERROR
    int value;
} invalid;

void main()
{
    barrier();
    memoryBarrier();
    memoryBarrierAtomicCounter();
    memoryBarrierBuffer();
    memoryBarrierShared();
    memoryBarrierImage();
    groupMemoryBarrier();
    value = int(values[gl_LocalInvocationIndex]);
}

layout(location = 2) in vec3 v3;      // ERROR
in float f;                           // ERROR
out float fo;                         // ERROR

shared vec4 s;
layout(location = 2) shared vec4 sl;  // ERROR
shared float fs = 4.2;                // ERROR

layout(local_size_x = 2, local_size_y = 3, local_size_z = 4) out;  // ERROR

int arrX[gl_WorkGroupSize.x];
int arrY[gl_WorkGroupSize.y];
int arrZ[gl_WorkGroupSize.z];

readonly buffer roblock
{
    int value;
    float values[];
} ro;

void foo()
{
    ro.values[2] = 4.7;        // ERROR, readonly
    ro.values.length();
    ++s;
}

buffer vec4 v;  // ERROR

uniform usampler2D us2dbad;  // ERROR, default precision

precision highp usampler2D;
precision highp iimage2DArray;
precision highp iimage2D;

uniform usampler2D us2d;

uniform iimage2DArray ii2dabad;  // ERROR, not writeonly
uniform writeonly iimage2DArray ii2da;

layout(r32i) uniform iimage2D iimg2D;
layout(rgba32i) uniform readonly iimage2D iimg2Drgba;
layout(rgba32f) uniform readonly image2D img2Drgba;
layout(r32ui) uniform uimage2D uimg2D;

void qux()
{
    int i = 4;
    imageAtomicCompSwap(iimg2D, ivec2(i,i), i, i);// ERROR no longer in 310
    imageAtomicAdd(uimg2D, ivec2(i,i), uint(i));  // ERROR no longer in 310
    imageAtomicMin(iimg2Drgba, ivec2(i,i), i);    // ERROR no longer in 310  // ERROR iimg2Drgba does not have r32i layout
    imageAtomicMax(img2Drgba, ivec2(i,i), i);     // ERROR no longer in 310  // ERROR img2Drgba is not integer image
    ivec4 pos = imageLoad(iimg2D, ivec2(i,i));
    imageStore(ii2da, ivec3(i,i,i), ivec4(0));
    imageLoad(img2Drgba, ivec2(i,i));
    imageLoad(ii2da, ivec3(i,i,i));       // ERROR, drops writeonly
}

volatile float vol; // ERROR, not an image
readonly int vol2;  // ERROR, not an image

void passr(coherent readonly iimage2D image)
{
}

layout(r32i) coherent readonly uniform iimage2D qualim1;
layout(r32i) coherent restrict readonly uniform iimage2D qualim2;

void passrc()
{
    passr(qualim1);
    passr(qualim2);   // ERROR, drops restrict
    passr(iimg2D);
}

layout(rg8i)     uniform readonly uimage2D i1bad; // ERROR, type mismatch
layout(rgba32i)  uniform readonly image2D i2bad;  // ERROR, type mismatch
layout(rgba32f)  uniform readonly uimage2D i3bad; // ERROR, type mismatch
layout(r8_snorm) uniform readonly iimage2D i4bad; // ERROR, type mismatch
layout(rgba32ui) uniform readonly iimage2D i5bad; // ERROR, type mismatch
layout(r8ui)     uniform readonly iimage2D i6bad; // ERROR, type mismatch

layout(binding = 0) uniform atomic_uint counter;

uint func(atomic_uint c)
{
    return atomicCounterIncrement(c);
}

uint func2(out atomic_uint c) // ERROR, output
{
    return counter;           // ERROR, type mismatch
    return atomicCounter(counter);
}

void mainAC()
{
     atomic_uint non_uniform_counter; // ERROR
     uint val = atomicCounter(counter);
     atomicCounterDecrement(counter);
}

layout(binding = 1) uniform mediump atomic_uint counterBad;  // ERROR, not highp

layout(binding = 2, offset = 4) uniform atomic_uint countArr[4];
uniform int i;

void opac()
{
    int a[3];
    a[counter];         // ERROR, non-integer
    countArr[2];
    countArr[i];
}

shared int atomi;
shared uint atomu;

void atoms()
{
    int origi = atomicAdd(atomi, 3);
    uint origu = atomicAnd(atomu, 7u);
    origi = atomicExchange(atomi, 4);
    origu = atomicCompSwap(atomu, 10u, 8u);
}

precision highp atomic_uint;
precision lowp atomic_uint;   // ERROR

precise int pfoo;  // ERROR, reserved

dmat2x4 dm;                     // ERROR
uniform samplerCubeArray sca;   // ERROR
uniform iimage2DRect i2dr;      // ERROR
uniform image2DMS i2dms;        // ERROR
uniform uimage2DMSArray u2dmsa; // ERROR

layout(r32f)  coherent volatile restrict readonly writeonly uniform  image2D okay1;
layout(r32i)  coherent volatile restrict readonly           uniform iimage2D okay2;
layout(r32ui) coherent volatile restrict          writeonly uniform uimage2D okay3;
layout(r32f)  coherent volatile restrict                    uniform  image2D okay4;
 
layout(rgba32f)  coherent volatile restrict                 uniform  image2D badQ1;  // ERROR, bad qualifiers
layout(rgba8i)   coherent volatile restrict                 uniform iimage2D badQ2;  // ERROR, bad qualifiers
layout(rgba16ui) coherent volatile restrict                 uniform uimage2D badQ3;  // ERROR, bad qualifiers

writeonly buffer woblock
{
    int value;
    float values[];
} wo;

void foowo()
{
    float g;
    g = wo.values[2];            // ERROR, writeonly
    float f = wo.values[2];      // ERROR, writeonly
    ++wo.values[2];              // ERROR, writeonly
    wo.values[2]--;              // ERROR, writeonly
    f + wo.values[2];            // ERROR, writeonly
    wo.values[2] - f;            // ERROR, writeonly
    bool b;
    b ? f : wo.values[2];        // ERROR, writeonly
    b ? wo.values[2] : f;        // ERROR, writeonly
    if (f == wo.values[2])       // ERROR, writeonly
        ++f;
    if (f >= wo.values[2])       // ERROR, writeonly
        ++f;
    f = vec3(wo.values[2]).x;    // ERROR, writeonly
    ~wo.value;                   // ERROR, writeonly
    wo.values[2] = 3.4;
}

buffer multioblock
{
    readonly int value;
    writeonly float values[];
} multio;

void foomultio()
{
    float g;
    g = wo.values[2];            // ERROR, writeonly
    ~wo.value;
    wo.values[2] = 3.4;
    wo.value = 2;                // ERROR, readonly
}

in inb {     // ERROR
    int a;
} inbi;

out outb {     // ERROR
    int a;
} outbi;

float t__;  // ERROR, no __ until revision 310

    // ERROR, no __ until revision 310
#define __D

shared vec4 arr[2][3][4];