Add support for images in the compiler

src/common/utilities.cpp

@@ -247,7 +247,19 @@ int VariableRowCount(GLenum type)
       case GL_SAMPLER_2D_SHADOW:
       case GL_SAMPLER_CUBE_SHADOW:
       case GL_SAMPLER_2D_ARRAY_SHADOW:
-        return 1;
+      case GL_IMAGE_2D:
+      case GL_INT_IMAGE_2D:
+      case GL_UNSIGNED_INT_IMAGE_2D:
+      case GL_IMAGE_2D_ARRAY:
+      case GL_INT_IMAGE_2D_ARRAY:
+      case GL_UNSIGNED_INT_IMAGE_2D_ARRAY:
+      case GL_IMAGE_3D:
+      case GL_INT_IMAGE_3D:
+      case GL_UNSIGNED_INT_IMAGE_3D:
+      case GL_IMAGE_CUBE:
+      case GL_INT_IMAGE_CUBE:
+      case GL_UNSIGNED_INT_IMAGE_CUBE:
+          return 1;
       case GL_FLOAT_MAT2:
       case GL_FLOAT_MAT3x2:
       case GL_FLOAT_MAT4x2:

src/compiler/translator/BaseTypes.h

@@ -76,19 +76,98 @@ enum TBasicType
     EbtSampler2DShadow,
     EbtSamplerCubeShadow,
     EbtSampler2DArrayShadow,
-    EbtGuardSamplerEnd,    // non type: see implementation of IsSampler()
-    EbtGSampler2D,         // non type: represents sampler2D, isampler2D, and usampler2D
-    EbtGSampler3D,         // non type: represents sampler3D, isampler3D, and usampler3D
-    EbtGSamplerCube,       // non type: represents samplerCube, isamplerCube, and usamplerCube
-    EbtGSampler2DArray,    // non type: represents sampler2DArray, isampler2DArray, and usampler2DArray
+    EbtGuardSamplerEnd,  // non type: see implementation of IsSampler()
+    EbtGSampler2D,       // non type: represents sampler2D, isampler2D, and usampler2D
+    EbtGSampler3D,       // non type: represents sampler3D, isampler3D, and usampler3D
+    EbtGSamplerCube,     // non type: represents samplerCube, isamplerCube, and usamplerCube
+    EbtGSampler2DArray,  // non type: represents sampler2DArray, isampler2DArray, and
+                         // usampler2DArray
+
+    // images
+    EbtGuardImageBegin,
+    EbtImage2D,
+    EbtIImage2D,
+    EbtUImage2D,
+    EbtImage3D,
+    EbtIImage3D,
+    EbtUImage3D,
+    EbtImage2DArray,
+    EbtIImage2DArray,
+    EbtUImage2DArray,
+    EbtImageCube,
+    EbtIImageCube,
+    EbtUImageCube,
+    EbtGuardImageEnd,
+
+    EbtGuardGImageBegin,
+    EbtGImage2D,       // non type: represents image2D, uimage2D, iimage2D
+    EbtGImage3D,       // non type: represents image3D, uimage3D, iimage3D
+    EbtGImage2DArray,  // non type: represents image2DArray, uimage2DArray, iimage2DArray
+    EbtGImageCube,     // non type: represents imageCube, uimageCube, iimageCube
+    EbtGuardGImageEnd,
+
     EbtStruct,
     EbtInterfaceBlock,
-    EbtAddress,            // should be deprecated??
+    EbtAddress,  // should be deprecated??
 
     // end of list
     EbtLast
 };
 
+inline TBasicType convertGImageToFloatImage(TBasicType type)
+{
+    switch (type)
+    {
+        case EbtGImage2D:
+            return EbtImage2D;
+        case EbtGImage3D:
+            return EbtImage3D;
+        case EbtGImage2DArray:
+            return EbtImage2DArray;
+        case EbtGImageCube:
+            return EbtImageCube;
+        default:
+            UNREACHABLE();
+    }
+    return EbtLast;
+}
+
+inline TBasicType convertGImageToIntImage(TBasicType type)
+{
+    switch (type)
+    {
+        case EbtGImage2D:
+            return EbtIImage2D;
+        case EbtGImage3D:
+            return EbtIImage3D;
+        case EbtGImage2DArray:
+            return EbtIImage2DArray;
+        case EbtGImageCube:
+            return EbtIImageCube;
+        default:
+            UNREACHABLE();
+    }
+    return EbtLast;
+}
+
+inline TBasicType convertGImageToUnsignedImage(TBasicType type)
+{
+    switch (type)
+    {
+        case EbtGImage2D:
+            return EbtUImage2D;
+        case EbtGImage3D:
+            return EbtUImage3D;
+        case EbtGImage2DArray:
+            return EbtUImage2DArray;
+        case EbtGImageCube:
+            return EbtUImageCube;
+        default:
+            UNREACHABLE();
+    }
+    return EbtLast;
+}
+
 const char* getBasicString(TBasicType t);
 
 inline bool IsSampler(TBasicType type)
@@ -96,6 +175,22 @@ inline bool IsSampler(TBasicType type)
     return type > EbtGuardSamplerBegin && type < EbtGuardSamplerEnd;
 }
 
+inline bool IsImage(TBasicType type)
+{
+    return type > EbtGuardImageBegin && type < EbtGuardImageEnd;
+}
+
+inline bool IsGImage(TBasicType type)
+{
+    return type > EbtGuardGImageBegin && type < EbtGuardGImageEnd;
+}
+
+inline bool IsOpaqueType(TBasicType type)
+{
+    // TODO (mradev): add atomic types as opaque.
+    return IsSampler(type) || IsImage(type);
+}
+
 inline bool IsIntegerSampler(TBasicType type)
 {
     switch (type)
@@ -126,6 +221,56 @@ inline bool IsIntegerSampler(TBasicType type)
     return false;
 }
 
+inline bool IsFloatImage(TBasicType type)
+{
+    switch (type)
+    {
+        case EbtImage2D:
+        case EbtImage3D:
+        case EbtImage2DArray:
+        case EbtImageCube:
+            return true;
+        default:
+            break;
+    }
+
+    return false;
+}
+
+inline bool IsIntegerImage(TBasicType type)
+{
+
+    switch (type)
+    {
+        case EbtIImage2D:
+        case EbtIImage3D:
+        case EbtIImage2DArray:
+        case EbtIImageCube:
+            return true;
+        default:
+            break;
+    }
+
+    return false;
+}
+
+inline bool IsUnsignedImage(TBasicType type)
+{
+
+    switch (type)
+    {
+        case EbtUImage2D:
+        case EbtUImage3D:
+        case EbtUImage2DArray:
+        case EbtUImageCube:
+            return true;
+        default:
+            break;
+    }
+
+    return false;
+}
+
 inline bool IsSampler2D(TBasicType type)
 {
     switch (type)
@@ -283,7 +428,7 @@ inline bool IsInteger(TBasicType type)
 
 inline bool SupportsPrecision(TBasicType type)
 {
-    return type == EbtFloat || type == EbtInt || type == EbtUInt || IsSampler(type);
+    return type == EbtFloat || type == EbtInt || type == EbtUInt || IsOpaqueType(type);
 }
 
 //
@@ -360,6 +505,10 @@ enum TQualifier
     EvqGlobalInvocationID,
     EvqLocalInvocationIndex,
 
+    // GLSL ES 3.1 memory qualifiers
+    EvqReadOnly,
+    EvqWriteOnly,
+
     // end of list
     EvqLast
 };
@@ -369,6 +518,24 @@ inline bool IsQualifierUnspecified(TQualifier qualifier)
     return (qualifier == EvqTemporary || qualifier == EvqGlobal);
 }
 
+enum TLayoutImageInternalFormat
+{
+    EiifUnspecified,
+    EiifRGBA32F,
+    EiifRGBA16F,
+    EiifR32F,
+    EiifRGBA32UI,
+    EiifRGBA16UI,
+    EiifRGBA8UI,
+    EiifR32UI,
+    EiifRGBA32I,
+    EiifRGBA16I,
+    EiifRGBA8I,
+    EiifR32I,
+    EiifRGBA8,
+    EiifRGBA8_SNORM
+};
+
 enum TLayoutMatrixPacking
 {
     EmpUnspecified,
@@ -394,6 +561,9 @@ struct TLayoutQualifier
     // Compute shader layout qualifiers.
     sh::WorkGroupSize localSize;
 
+    // Image format layout qualifier
+    TLayoutImageInternalFormat imageInternalFormat;
+
     static TLayoutQualifier create()
     {
         TLayoutQualifier layoutQualifier;
@@ -405,20 +575,23 @@ struct TLayoutQualifier
 
         layoutQualifier.localSize.fill(-1);
 
+        layoutQualifier.imageInternalFormat = EiifUnspecified;
         return layoutQualifier;
     }
 
     bool isEmpty() const
     {
         return location == -1 && matrixPacking == EmpUnspecified &&
-               blockStorage == EbsUnspecified && !localSize.isAnyValueSet();
+               blockStorage == EbsUnspecified && !localSize.isAnyValueSet() &&
+               imageInternalFormat == EiifUnspecified;
     }
 
     bool isCombinationValid() const
     {
         bool workSizeSpecified = localSize.isAnyValueSet();
         bool otherLayoutQualifiersSpecified =
-            (location != -1 || matrixPacking != EmpUnspecified || blockStorage != EbsUnspecified);
+            (location != -1 || matrixPacking != EmpUnspecified || blockStorage != EbsUnspecified ||
+             imageInternalFormat != EiifUnspecified);
 
         // we can have either the work group size specified, or the other layout qualifiers
         return !(workSizeSpecified && otherLayoutQualifiersSpecified);
@@ -430,6 +603,26 @@ struct TLayoutQualifier
     }
 };
 
+struct TMemoryQualifier
+{
+    // GLSL ES 3.10 Revision 4, 4.9 Memory Access Qualifiers
+    // An image can be qualified as both readonly and writeonly. It still can be can be used with
+    // imageSize().
+    bool readonly;
+    bool writeonly;
+    static TMemoryQualifier create()
+    {
+        TMemoryQualifier memoryQualifier;
+
+        memoryQualifier.readonly  = false;
+        memoryQualifier.writeonly = false;
+
+        return memoryQualifier;
+    }
+
+    bool isEmpty() { return !readonly && !writeonly; }
+};
+
 inline const char *getWorkGroupSizeString(size_t dimension)
 {
     switch (dimension)
@@ -500,6 +693,8 @@ inline const char* getQualifierString(TQualifier q)
     case EvqLocalInvocationID:      return "LocalInvocationID";
     case EvqGlobalInvocationID:     return "GlobalInvocationID";
     case EvqLocalInvocationIndex:   return "LocalInvocationIndex";
+    case EvqReadOnly:               return "readonly";
+    case EvqWriteOnly:              return "writeonly";
     default: UNREACHABLE();         return "unknown qualifier";
     }
     // clang-format on
@@ -528,4 +723,40 @@ inline const char* getBlockStorageString(TLayoutBlockStorage bsq)
     }
 }
 
+inline const char *getImageInternalFormatString(TLayoutImageInternalFormat iifq)
+{
+    switch (iifq)
+    {
+        case EiifRGBA32F:
+            return "rgba32f";
+        case EiifRGBA16F:
+            return "rgba16f";
+        case EiifR32F:
+            return "r32f";
+        case EiifRGBA32UI:
+            return "rgba32ui";
+        case EiifRGBA16UI:
+            return "rgba16ui";
+        case EiifRGBA8UI:
+            return "rgba8ui";
+        case EiifR32UI:
+            return "r32ui";
+        case EiifRGBA32I:
+            return "rgba32i";
+        case EiifRGBA16I:
+            return "rgba16i";
+        case EiifRGBA8I:
+            return "rgba8i";
+        case EiifR32I:
+            return "r32i";
+        case EiifRGBA8:
+            return "rgba8";
+        case EiifRGBA8_SNORM:
+            return "rgba8_snorm";
+        default:
+            UNREACHABLE();
+            return "unknown internal image format";
+    }
+}
+
 #endif // COMPILER_TRANSLATOR_BASETYPES_H_

src/compiler/translator/Compiler.cpp

@@ -517,14 +517,10 @@ bool TCompiler::InitBuiltInSymbolTable(const ShBuiltInResources &resources)
     symbolTable.push();   // ESSL3_1_BUILTINS
 
     TPublicType integer;
-    integer.setBasicType(EbtInt);
-    integer.initializeSizeForScalarTypes();
-    integer.array = false;
+    integer.initializeBasicType(EbtInt);
 
     TPublicType floatingPoint;
-    floatingPoint.setBasicType(EbtFloat);
-    floatingPoint.initializeSizeForScalarTypes();
-    floatingPoint.array = false;
+    floatingPoint.initializeBasicType(EbtFloat);
 
     switch(shaderType)
     {
@@ -563,9 +559,7 @@ void TCompiler::initSamplerDefaultPrecision(TBasicType samplerType)
 {
     ASSERT(samplerType > EbtGuardSamplerBegin && samplerType < EbtGuardSamplerEnd);
     TPublicType sampler;
-    sampler.initializeSizeForScalarTypes();
-    sampler.setBasicType(samplerType);
-    sampler.array         = false;
+    sampler.initializeBasicType(samplerType);
     symbolTable.setDefaultPrecision(sampler, EbpLow);
 }
 

src/compiler/translator/Initialize.cpp

@@ -18,6 +18,7 @@
 
 void InsertBuiltInFunctions(sh::GLenum type, ShShaderSpec spec, const ShBuiltInResources &resources, TSymbolTable &symbolTable)
 {
+    const TType *voidType = TCache::getType(EbtVoid);
     const TType *float1 = TCache::getType(EbtFloat);
     const TType *float2 = TCache::getType(EbtFloat, 2);
     const TType *float3 = TCache::getType(EbtFloat, 3);
@@ -469,6 +470,26 @@ void InsertBuiltInFunctions(sh::GLenum type, ShShaderSpec spec, const ShBuiltInR
     symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureProjGradOffset", gsampler3D, float4, float3, float3, int3);
     symbolTable.insertBuiltIn(ESSL3_BUILTINS, float1, "textureProjGradOffset", sampler2DShadow, float4, float2, float2, int2);
 
+    const TType *gimage2D      = TCache::getType(EbtGImage2D);
+    const TType *gimage3D      = TCache::getType(EbtGImage3D);
+    const TType *gimage2DArray = TCache::getType(EbtGImage2DArray);
+    const TType *gimageCube    = TCache::getType(EbtGImageCube);
+
+    symbolTable.insertBuiltIn(ESSL3_1_BUILTINS, voidType, "imageStore", gimage2D, int2, gvec4);
+    symbolTable.insertBuiltIn(ESSL3_1_BUILTINS, voidType, "imageStore", gimage3D, int3, gvec4);
+    symbolTable.insertBuiltIn(ESSL3_1_BUILTINS, voidType, "imageStore", gimage2DArray, int3, gvec4);
+    symbolTable.insertBuiltIn(ESSL3_1_BUILTINS, voidType, "imageStore", gimageCube, int3, gvec4);
+
+    symbolTable.insertBuiltIn(ESSL3_1_BUILTINS, gvec4, "imageLoad", gimage2D, int2);
+    symbolTable.insertBuiltIn(ESSL3_1_BUILTINS, gvec4, "imageLoad", gimage3D, int3);
+    symbolTable.insertBuiltIn(ESSL3_1_BUILTINS, gvec4, "imageLoad", gimage2DArray, int3);
+    symbolTable.insertBuiltIn(ESSL3_1_BUILTINS, gvec4, "imageLoad", gimageCube, int3);
+
+    symbolTable.insertBuiltIn(ESSL3_1_BUILTINS, int2, "imageSize", gimage2D);
+    symbolTable.insertBuiltIn(ESSL3_1_BUILTINS, int3, "imageSize", gimage3D);
+    symbolTable.insertBuiltIn(ESSL3_1_BUILTINS, int3, "imageSize", gimage2DArray);
+    symbolTable.insertBuiltIn(ESSL3_1_BUILTINS, int3, "imageSize", gimageCube);
+
     //
     // Depth range in window coordinates
     //

src/compiler/translator/IntermNode.h

@@ -150,6 +150,7 @@ class TIntermTyped : public TIntermNode
     TBasicType getBasicType() const { return mType.getBasicType(); }
     TQualifier getQualifier() const { return mType.getQualifier(); }
     TPrecision getPrecision() const { return mType.getPrecision(); }
+    TMemoryQualifier getMemoryQualifier() const { return mType.getMemoryQualifier(); }
     int getCols() const { return mType.getCols(); }
     int getRows() const { return mType.getRows(); }
     int getNominalSize() const { return mType.getNominalSize(); }

src/compiler/translator/OutputGLSLBase.cpp

@@ -49,6 +49,32 @@ bool isSingleStatement(TIntermNode *node)
     return true;
 }
 
+// If SH_SCALARIZE_VEC_AND_MAT_CONSTRUCTOR_ARGS is enabled, layout qualifiers are spilled whenever
+// variables with specified layout qualifiers are copied. Additional checks are needed against the
+// type and storage qualifier of the variable to verify that layout qualifiers have to be outputted.
+// TODO (mradev): Fix layout qualifier spilling in ScalarizeVecAndMatConstructorArgs and remove
+// NeedsToWriteLayoutQualifier.
+bool NeedsToWriteLayoutQualifier(const TType &type)
+{
+    if (type.getBasicType() == EbtInterfaceBlock)
+    {
+        return false;
+    }
+
+    const TLayoutQualifier &layoutQualifier = type.getLayoutQualifier();
+
+    if ((type.getQualifier() == EvqFragmentOut || type.getQualifier() == EvqVertexIn) &&
+        layoutQualifier.location >= 0)
+    {
+        return true;
+    }
+    if (IsImage(type.getBasicType()) && layoutQualifier.imageInternalFormat != EiifUnspecified)
+    {
+        return true;
+    }
+    return false;
+}
+
 }  // namespace
 
 TOutputGLSLBase::TOutputGLSLBase(TInfoSinkBase &objSink,
@@ -92,15 +118,30 @@ void TOutputGLSLBase::writeBuiltInFunctionTriplet(
 
 void TOutputGLSLBase::writeLayoutQualifier(const TType &type)
 {
+    if (!NeedsToWriteLayoutQualifier(type))
+    {
+        return;
+    }
+
+    TInfoSinkBase &out                      = objSink();
+    const TLayoutQualifier &layoutQualifier = type.getLayoutQualifier();
+    out << "layout(";
+
     if (type.getQualifier() == EvqFragmentOut || type.getQualifier() == EvqVertexIn)
     {
-        const TLayoutQualifier &layoutQualifier = type.getLayoutQualifier();
         if (layoutQualifier.location >= 0)
         {
-            TInfoSinkBase &out = objSink();
-            out << "layout(location = " << layoutQualifier.location << ") ";
+            out << "location = " << layoutQualifier.location;
         }
     }
+
+    if (IsImage(type.getBasicType()) && layoutQualifier.imageInternalFormat != EiifUnspecified)
+    {
+        ASSERT(type.getQualifier() == EvqTemporary || type.getQualifier() == EvqUniform);
+        out << getImageInternalFormatString(layoutQualifier.imageInternalFormat);
+    }
+
+    out << ") ";
 }
 
 void TOutputGLSLBase::writeVariableType(const TType &type)
@@ -141,6 +182,20 @@ void TOutputGLSLBase::writeVariableType(const TType &type)
             out << type.getQualifierString() << " ";
         }
     }
+
+    const TMemoryQualifier &memoryQualifier = type.getMemoryQualifier();
+    if (memoryQualifier.readonly)
+    {
+        ASSERT(IsImage(type.getBasicType()));
+        out << "readonly ";
+    }
+
+    if (memoryQualifier.writeonly)
+    {
+        ASSERT(IsImage(type.getBasicType()));
+        out << "writeonly ";
+    }
+
     // Declare the struct if we have not done so already.
     if (type.getBasicType() == EbtStruct && !structDeclared(type.getStruct()))
     {

src/compiler/translator/ParseContext.h

@@ -162,12 +162,12 @@ class TParseContext : angle::NonCopyable
     bool checkIsNotSampler(const TSourceLoc &line,
                            const TTypeSpecifierNonArray &pType,
                            const char *reason);
+    bool checkIsNotImage(const TSourceLoc &line,
+                         const TTypeSpecifierNonArray &pType,
+                         const char *reason);
     void checkDeclaratorLocationIsNotSpecified(const TSourceLoc &line, const TPublicType &pType);
     void checkLocationIsNotSpecified(const TSourceLoc &location,
                                      const TLayoutQualifier &layoutQualifier);
-    void checkOutParameterIsNotSampler(const TSourceLoc &line,
-                                       TQualifier qualifier,
-                                       const TType &type);
     void checkIsParameterQualifierValid(const TSourceLoc &line,
                                         const TTypeQualifierBuilder &typeQualifierBuilder,
                                         TType *type);
@@ -179,7 +179,8 @@ class TParseContext : angle::NonCopyable
                                        int versionRequired);
     bool checkWorkGroupSizeIsNotSpecified(const TSourceLoc &location,
                                           const TLayoutQualifier &layoutQualifier);
-
+    bool checkInternalFormatIsNotSpecified(const TSourceLoc &location,
+                                           TLayoutImageInternalFormat internalFormat);
     void functionCallLValueErrorCheck(const TFunction *fnCandidate, TIntermAggregate *fnCall);
     void checkInvariantVariableQualifier(bool invariant,
                                          const TQualifier qualifier,
@@ -187,7 +188,7 @@ class TParseContext : angle::NonCopyable
     void checkInputOutputTypeIsValidES3(const TQualifier qualifier,
                                         const TPublicType &type,
                                         const TSourceLoc &qualifierLocation);
-
+    void checkLocalVariableConstStorageQualifier(const TQualifierWrapperBase &qualifier);
     const TPragma &pragma() const { return mDirectiveHandler.pragma(); }
     const TExtensionBehavior &extensionBehavior() const { return mDirectiveHandler.extensionBehavior(); }
     bool supportsExtension(const char *extension);
@@ -195,7 +196,6 @@ class TParseContext : angle::NonCopyable
     void handleExtensionDirective(const TSourceLoc &loc, const char *extName, const char *behavior);
     void handlePragmaDirective(const TSourceLoc &loc, const char *name, const char *value, bool stdgl);
 
-    bool containsSampler(const TType &type);
     const TFunction* findFunction(
         const TSourceLoc &line, TFunction *pfnCall, int inputShaderVersion, bool *builtIn = 0);
     bool executeInitializer(const TSourceLoc &line,
@@ -356,6 +356,9 @@ class TParseContext : angle::NonCopyable
     TIntermBranch *addBranch(TOperator op, TIntermTyped *returnValue, const TSourceLoc &loc);
 
     void checkTextureOffsetConst(TIntermAggregate *functionCall);
+    void checkImageMemoryAccessForBuiltinFunctions(TIntermAggregate *functionCall);
+    void checkImageMemoryAccessForUserDefinedFunctions(const TFunction *functionDefinition,
+                                                       const TIntermAggregate *functionCall);
     TIntermTyped *addFunctionCallOrMethod(TFunction *fnCall,
                                           TIntermNode *paramNode,
                                           TIntermNode *thisNode,
@@ -392,6 +395,18 @@ class TParseContext : angle::NonCopyable
     // Assumes that multiplication op has already been set based on the types.
     bool isMultiplicationTypeCombinationValid(TOperator op, const TType &left, const TType &right);
 
+    bool checkIsMemoryQualifierNotSpecified(const TMemoryQualifier &memoryQualifier,
+                                            const TSourceLoc &location);
+    void checkOutParameterIsNotImage(const TSourceLoc &line,
+                                     TQualifier qualifier,
+                                     const TType &type);
+    void checkOutParameterIsNotOpaqueType(const TSourceLoc &line,
+                                          TQualifier qualifier,
+                                          const TType &type);
+    void checkOutParameterIsNotSampler(const TSourceLoc &line,
+                                       TQualifier qualifier,
+                                       const TType &type);
+
     TIntermTyped *addBinaryMathInternal(
         TOperator op, TIntermTyped *left, TIntermTyped *right, const TSourceLoc &loc);
     TIntermTyped *createAssign(

src/compiler/translator/QualifierTypes.cpp

@@ -48,6 +48,11 @@ TLayoutQualifier JoinLayoutQualifiers(TLayoutQualifier leftQualifier,
         }
     }
 
+    if (rightQualifier.imageInternalFormat != EiifUnspecified)
+    {
+        joinedQualifier.imageInternalFormat = rightQualifier.imageInternalFormat;
+    }
+
     return joinedQualifier;
 }
 }  // namespace sh
@@ -191,6 +196,31 @@ bool HasRepeatingQualifiers(const TTypeQualifierBuilder::QualifierSequence &qual
                 }
                 break;
             }
+            case QtMemory:
+            {
+                // Go over all of the memory qualifiers up until the current one and check for
+                // repetitions.
+                // Having both readonly and writeonly in a sequence is valid.
+                // GLSL ES 3.10 Revision 4, 4.9 Memory Access Qualifiers
+                TQualifier currentQualifier =
+                    static_cast<const TMemoryQualifierWrapper *>(qualifiers[i])->getQualifier();
+                for (size_t j = 1; j < i; ++j)
+                {
+                    if (qualifiers[j]->getType() == QtMemory)
+                    {
+                        const TMemoryQualifierWrapper *previousQualifierWrapper =
+                            static_cast<const TMemoryQualifierWrapper *>(qualifiers[j]);
+                        TQualifier previousQualifier = previousQualifierWrapper->getQualifier();
+                        if (currentQualifier == previousQualifier)
+                        {
+                            *errorMessage = previousQualifierWrapper->getQualifierString().c_str();
+                            *errorMessage += " specified multiple times";
+                            return true;
+                        }
+                    }
+                }
+                break;
+            }
             default:
                 UNREACHABLE();
         }
@@ -263,6 +293,13 @@ bool AreQualifiersInOrder(const TTypeQualifierBuilder::QualifierSequence &qualif
                 }
                 foundStorage = true;
                 break;
+            case QtMemory:
+                if (foundPrecision)
+                {
+                    *errorMessage = "Precision qualifiers have to be after memory qualifiers.";
+                    return false;
+                }
+                break;
             case QtPrecision:
                 foundPrecision = true;
                 break;
@@ -392,6 +429,22 @@ bool JoinParameterStorageQualifier(TQualifier *joinedQualifier, TQualifier stora
     return true;
 }
 
+bool JoinMemoryQualifier(TMemoryQualifier *joinedMemoryQualifier, TQualifier memoryQualifier)
+{
+    switch (memoryQualifier)
+    {
+        case EvqReadOnly:
+            joinedMemoryQualifier->readonly = true;
+            break;
+        case EvqWriteOnly:
+            joinedMemoryQualifier->writeonly = true;
+            break;
+        default:
+            UNREACHABLE();
+    }
+    return true;
+}
+
 TTypeQualifier GetVariableTypeQualifierFromSortedSequence(
     const TTypeQualifierBuilder::QualifierSequence &sortedSequence,
     TDiagnostics *diagnostics)
@@ -445,6 +498,11 @@ TTypeQualifier GetVariableTypeQualifierFromSortedSequence(
                     static_cast<const TPrecisionQualifierWrapper *>(qualifier)->getQualifier();
                 ASSERT(typeQualifier.precision != EbpUndefined);
                 break;
+            case QtMemory:
+                isQualifierValid = JoinMemoryQualifier(
+                    &typeQualifier.memoryQualifier,
+                    static_cast<const TMemoryQualifierWrapper *>(qualifier)->getQualifier());
+                break;
             default:
                 UNREACHABLE();
         }
@@ -474,6 +532,11 @@ TTypeQualifier GetParameterTypeQualifierFromSortedSequence(
             case QtInterpolation:
             case QtLayout:
                 break;
+            case QtMemory:
+                isQualifierValid = JoinMemoryQualifier(
+                    &typeQualifier.memoryQualifier,
+                    static_cast<const TMemoryQualifierWrapper *>(qualifier)->getQualifier());
+                break;
             case QtStorage:
                 isQualifierValid = JoinParameterStorageQualifier(
                     &typeQualifier.qualifier,
@@ -548,6 +611,11 @@ unsigned int TStorageQualifierWrapper::getRank() const
     }
 }
 
+unsigned int TMemoryQualifierWrapper::getRank() const
+{
+    return 4u;
+}
+
 unsigned int TPrecisionQualifierWrapper::getRank() const
 {
     return 5u;
@@ -555,6 +623,7 @@ unsigned int TPrecisionQualifierWrapper::getRank() const
 
 TTypeQualifier::TTypeQualifier(TQualifier scope, const TSourceLoc &loc)
     : layoutQualifier(TLayoutQualifier::create()),
+      memoryQualifier(TMemoryQualifier::create()),
       precision(EbpUndefined),
       qualifier(scope),
       invariant(false),

src/compiler/translator/QualifierTypes.h

@@ -27,7 +27,8 @@ enum TQualifierType
     QtInterpolation,
     QtLayout,
     QtStorage,
-    QtPrecision
+    QtPrecision,
+    QtMemory
 };
 
 class TQualifierWrapperBase : angle::NonCopyable
@@ -127,6 +128,24 @@ class TPrecisionQualifierWrapper final : public TQualifierWrapperBase
     TPrecision mPrecisionQualifier;
 };
 
+class TMemoryQualifierWrapper final : public TQualifierWrapperBase
+{
+  public:
+    TMemoryQualifierWrapper(TQualifier memoryQualifier, const TSourceLoc &line)
+        : TQualifierWrapperBase(line), mMemoryQualifier(memoryQualifier)
+    {
+    }
+    ~TMemoryQualifierWrapper() {}
+
+    TQualifierType getType() const { return QtMemory; }
+    TString getQualifierString() const { return ::getQualifierString(mMemoryQualifier); }
+    TQualifier getQualifier() const { return mMemoryQualifier; }
+    unsigned int getRank() const;
+
+  private:
+    TQualifier mMemoryQualifier;
+};
+
 // TTypeQualifier tightly covers type_qualifier from the grammar
 struct TTypeQualifier
 {
@@ -134,6 +153,7 @@ struct TTypeQualifier
     TTypeQualifier(TQualifier scope, const TSourceLoc &loc);
 
     TLayoutQualifier layoutQualifier;
+    TMemoryQualifier memoryQualifier;
     TPrecision precision;
     TQualifier qualifier;
     bool invariant;

src/compiler/translator/SymbolTable.cpp

@@ -249,6 +249,43 @@ void TSymbolTable::insertBuiltIn(ESymbolLevel level, TOperator op, const char *e
         insertBuiltIn(level, gvec4 ? TCache::getType(EbtInt, 4) : rvalue, name, TCache::getType(EbtISampler2DArray), ptype2, ptype3, ptype4, ptype5);
         insertBuiltIn(level, gvec4 ? TCache::getType(EbtUInt, 4) : rvalue, name, TCache::getType(EbtUSampler2DArray), ptype2, ptype3, ptype4, ptype5);
     }
+    else if (IsGImage(ptype1->getBasicType()))
+    {
+        insertUnmangledBuiltIn(name);
+
+        const TType *floatType    = TCache::getType(EbtFloat, 4);
+        const TType *intType      = TCache::getType(EbtInt, 4);
+        const TType *unsignedType = TCache::getType(EbtUInt, 4);
+
+        const TType *floatImage =
+            TCache::getType(convertGImageToFloatImage(ptype1->getBasicType()));
+        const TType *intImage = TCache::getType(convertGImageToIntImage(ptype1->getBasicType()));
+        const TType *unsignedImage =
+            TCache::getType(convertGImageToUnsignedImage(ptype1->getBasicType()));
+
+        // GLSL ES 3.10, Revision 4, 8.12 Image Functions
+        if (rvalue->getBasicType() == EbtGVec4)
+        {
+            // imageLoad
+            insertBuiltIn(level, floatType, name, floatImage, ptype2, ptype3, ptype4, ptype5);
+            insertBuiltIn(level, intType, name, intImage, ptype2, ptype3, ptype4, ptype5);
+            insertBuiltIn(level, unsignedType, name, unsignedImage, ptype2, ptype3, ptype4, ptype5);
+        }
+        else if (rvalue->getBasicType() == EbtVoid)
+        {
+            // imageStore
+            insertBuiltIn(level, rvalue, name, floatImage, ptype2, floatType, ptype4, ptype5);
+            insertBuiltIn(level, rvalue, name, intImage, ptype2, intType, ptype4, ptype5);
+            insertBuiltIn(level, rvalue, name, unsignedImage, ptype2, unsignedType, ptype4, ptype5);
+        }
+        else
+        {
+            // imageSize
+            insertBuiltIn(level, rvalue, name, floatImage, ptype2, ptype3, ptype4, ptype5);
+            insertBuiltIn(level, rvalue, name, intImage, ptype2, ptype3, ptype4, ptype5);
+            insertBuiltIn(level, rvalue, name, unsignedImage, ptype2, ptype3, ptype4, ptype5);
+        }
+    }
     else if (IsGenType(rvalue) || IsGenType(ptype1) || IsGenType(ptype2) || IsGenType(ptype3))
     {
         ASSERT(!ptype4 && !ptype5);

src/compiler/translator/Types.cpp

@@ -44,6 +44,30 @@ const char* getBasicString(TBasicType t)
         case EbtSampler2DArrayShadow: return "sampler2DArrayShadow";
         case EbtStruct:               return "structure";
         case EbtInterfaceBlock:       return "interface block";
+        case EbtImage2D:
+            return "image2D";
+        case EbtIImage2D:
+            return "iimage2D";
+        case EbtUImage2D:
+            return "uimage2D";
+        case EbtImage3D:
+            return "image3D";
+        case EbtIImage3D:
+            return "iimage3D";
+        case EbtUImage3D:
+            return "uimage3D";
+        case EbtImage2DArray:
+            return "image2DArray";
+        case EbtIImage2DArray:
+            return "iimage2DArray";
+        case EbtUImage2DArray:
+            return "uimage2DArray";
+        case EbtImageCube:
+            return "imageCube";
+        case EbtIImageCube:
+            return "iimageCube";
+        case EbtUImageCube:
+            return "uimageCube";
         default: UNREACHABLE();       return "unknown type";
     }
 }
@@ -53,6 +77,7 @@ TType::TType(const TPublicType &p)
       precision(p.precision),
       qualifier(p.qualifier),
       invariant(p.invariant),
+      memoryQualifier(p.memoryQualifier),
       layoutQualifier(p.layoutQualifier),
       primarySize(p.getPrimarySize()),
       secondarySize(p.getSecondarySize()),
@@ -283,6 +308,42 @@ TString TType::buildMangledName() const
       case EbtSampler2DArrayShadow:
         mangledName += "s2as";
         break;
+      case EbtImage2D:
+          mangledName += "im2";
+          break;
+      case EbtIImage2D:
+          mangledName += "iim2";
+          break;
+      case EbtUImage2D:
+          mangledName += "uim2";
+          break;
+      case EbtImage3D:
+          mangledName += "im3";
+          break;
+      case EbtIImage3D:
+          mangledName += "iim3";
+          break;
+      case EbtUImage3D:
+          mangledName += "uim3";
+          break;
+      case EbtImage2DArray:
+          mangledName += "im2a";
+          break;
+      case EbtIImage2DArray:
+          mangledName += "iim2a";
+          break;
+      case EbtUImage2DArray:
+          mangledName += "uim2a";
+          break;
+      case EbtImageCube:
+          mangledName += "imc";
+          break;
+      case EbtIImageCube:
+          mangledName += "iimc";
+          break;
+      case EbtUImageCube:
+          mangledName += "uimc";
+          break;
       case EbtStruct:
         mangledName += structure->mangledName();
         break;
@@ -381,6 +442,17 @@ bool TStructure::containsSamplers() const
     return false;
 }
 
+bool TStructure::containsImages() const
+{
+    for (size_t i = 0; i < mFields->size(); ++i)
+    {
+        const TType *fieldType = (*mFields)[i]->type();
+        if (IsImage(fieldType->getBasicType()) || fieldType->isStructureContainingImages())
+            return true;
+    }
+    return false;
+}
+
 void TStructure::createSamplerSymbols(const TString &structName,
                                       const TString &structAPIName,
                                       const unsigned int arrayOfStructsSize,

src/compiler/translator/Types.h

@@ -114,6 +114,7 @@ class TStructure : public TFieldListCollection
     bool containsArrays() const;
     bool containsType(TBasicType t) const;
     bool containsSamplers() const;
+    bool containsImages() const;
 
     void createSamplerSymbols(const TString &structName,
                               const TString &structAPIName,
@@ -229,10 +230,18 @@ class TType
   public:
     POOL_ALLOCATOR_NEW_DELETE();
     TType()
-        : type(EbtVoid), precision(EbpUndefined), qualifier(EvqGlobal), invariant(false),
+        : type(EbtVoid),
+          precision(EbpUndefined),
+          qualifier(EvqGlobal),
+          invariant(false),
+          memoryQualifier(TMemoryQualifier::create()),
           layoutQualifier(TLayoutQualifier::create()),
-          primarySize(0), secondarySize(0), array(false), arraySize(0),
-          interfaceBlock(nullptr), structure(nullptr)
+          primarySize(0),
+          secondarySize(0),
+          array(false),
+          arraySize(0),
+          interfaceBlock(nullptr),
+          structure(nullptr)
     {
     }
     explicit TType(TBasicType t, unsigned char ps = 1, unsigned char ss = 1)
@@ -240,6 +249,7 @@ class TType
           precision(EbpUndefined),
           qualifier(EvqGlobal),
           invariant(false),
+          memoryQualifier(TMemoryQualifier::create()),
           layoutQualifier(TLayoutQualifier::create()),
           primarySize(ps),
           secondarySize(ss),
@@ -249,12 +259,24 @@ class TType
           structure(0)
     {
     }
-    TType(TBasicType t, TPrecision p, TQualifier q = EvqTemporary,
-          unsigned char ps = 1, unsigned char ss = 1, bool a = false)
-        : type(t), precision(p), qualifier(q), invariant(false),
+    TType(TBasicType t,
+          TPrecision p,
+          TQualifier q     = EvqTemporary,
+          unsigned char ps = 1,
+          unsigned char ss = 1,
+          bool a           = false)
+        : type(t),
+          precision(p),
+          qualifier(q),
+          invariant(false),
+          memoryQualifier(TMemoryQualifier::create()),
           layoutQualifier(TLayoutQualifier::create()),
-          primarySize(ps), secondarySize(ss), array(a), arraySize(0),
-          interfaceBlock(0), structure(0)
+          primarySize(ps),
+          secondarySize(ss),
+          array(a),
+          arraySize(0),
+          interfaceBlock(0),
+          structure(0)
     {
     }
     explicit TType(const TPublicType &p);
@@ -263,6 +285,7 @@ class TType
           precision(p),
           qualifier(EvqTemporary),
           invariant(false),
+          memoryQualifier(TMemoryQualifier::create()),
           layoutQualifier(TLayoutQualifier::create()),
           primarySize(1),
           secondarySize(1),
@@ -272,12 +295,22 @@ class TType
           structure(userDef)
     {
     }
-    TType(TInterfaceBlock *interfaceBlockIn, TQualifier qualifierIn,
-          TLayoutQualifier layoutQualifierIn, int arraySizeIn)
-        : type(EbtInterfaceBlock), precision(EbpUndefined), qualifier(qualifierIn),
-          invariant(false), layoutQualifier(layoutQualifierIn),
-          primarySize(1), secondarySize(1), array(arraySizeIn > 0), arraySize(arraySizeIn),
-          interfaceBlock(interfaceBlockIn), structure(0)
+    TType(TInterfaceBlock *interfaceBlockIn,
+          TQualifier qualifierIn,
+          TLayoutQualifier layoutQualifierIn,
+          int arraySizeIn)
+        : type(EbtInterfaceBlock),
+          precision(EbpUndefined),
+          qualifier(qualifierIn),
+          invariant(false),
+          memoryQualifier(TMemoryQualifier::create()),
+          layoutQualifier(layoutQualifierIn),
+          primarySize(1),
+          secondarySize(1),
+          array(arraySizeIn > 0),
+          arraySize(arraySizeIn),
+          interfaceBlock(interfaceBlockIn),
+          structure(0)
     {
     }
 
@@ -322,6 +355,9 @@ class TType
 
     void setInvariant(bool i) { invariant = i; }
 
+    TMemoryQualifier getMemoryQualifier() const { return memoryQualifier; }
+    void setMemoryQualifier(const TMemoryQualifier &mq) { memoryQualifier = mq; }
+
     TLayoutQualifier getLayoutQualifier() const
     {
         return layoutQualifier;
@@ -547,6 +583,11 @@ class TType
         return structure ? structure->containsSamplers() : false;
     }
 
+    bool isStructureContainingImages() const
+    {
+        return structure ? structure->containsImages() : false;
+    }
+
     void createSamplerSymbols(const TString &structName,
                               const TString &structAPIName,
                               const unsigned int arrayOfStructsSize,
@@ -573,6 +614,7 @@ class TType
     TPrecision precision;
     TQualifier qualifier;
     bool invariant;
+    TMemoryQualifier memoryQualifier;
     TLayoutQualifier layoutQualifier;
     unsigned char primarySize; // size of vector or cols matrix
     unsigned char secondarySize; // rows of a matrix
@@ -641,6 +683,7 @@ struct TPublicType
 {
     TTypeSpecifierNonArray typeSpecifierNonArray;
     TLayoutQualifier layoutQualifier;
+    TMemoryQualifier memoryQualifier;
     TQualifier qualifier;
     bool invariant;
     TPrecision precision;
@@ -651,6 +694,7 @@ struct TPublicType
     {
         typeSpecifierNonArray = typeSpecifier;
         layoutQualifier       = TLayoutQualifier::create();
+        memoryQualifier       = TMemoryQualifier::create();
         qualifier             = q;
         invariant             = false;
         precision             = EbpUndefined;
@@ -658,16 +702,25 @@ struct TPublicType
         arraySize             = 0;
     }
 
+    void initializeBasicType(TBasicType basicType)
+    {
+        typeSpecifierNonArray.type          = basicType;
+        typeSpecifierNonArray.primarySize   = 1;
+        typeSpecifierNonArray.secondarySize = 1;
+        layoutQualifier                     = TLayoutQualifier::create();
+        memoryQualifier                     = TMemoryQualifier::create();
+        qualifier                           = EvqTemporary;
+        invariant                           = false;
+        precision                           = EbpUndefined;
+        array                               = false;
+        arraySize                           = 0;
+    }
+
     TBasicType getBasicType() const { return typeSpecifierNonArray.type; }
     void setBasicType(TBasicType basicType) { typeSpecifierNonArray.type = basicType; }
 
     unsigned char getPrimarySize() const { return typeSpecifierNonArray.primarySize; }
     unsigned char getSecondarySize() const { return typeSpecifierNonArray.secondarySize; }
-    void initializeSizeForScalarTypes()
-    {
-        typeSpecifierNonArray.primarySize   = 1;
-        typeSpecifierNonArray.secondarySize = 1;
-    }
 
     const TType *getUserDef() const { return typeSpecifierNonArray.userDef; }
     const TSourceLoc &getLine() const { return typeSpecifierNonArray.line; }

src/compiler/translator/glslang.l

@@ -71,6 +71,7 @@ static int reserved_word(yyscan_t yyscanner);
 static int ES2_reserved_ES3_keyword(TParseContext *context, int token);
 static int ES2_keyword_ES3_reserved(TParseContext *context, int token);
 static int ES2_ident_ES3_keyword(TParseContext *context, int token);
+static int ES2_ident_ES3_reserved_ES3_1_keyword(TParseContext *context, int token);
 static int uint_constant(TParseContext *context);
 static int int_constant(TParseContext *context);
 static int float_constant(yyscan_t yyscanner);
@@ -187,11 +188,24 @@ O           [0-7]
 
 "layout"  { return ES2_ident_ES3_keyword(context, LAYOUT); }
 
+"image2D" { return ES2_ident_ES3_reserved_ES3_1_keyword(context, IMAGE2D); }
+"iimage2D" { return ES2_ident_ES3_reserved_ES3_1_keyword(context, IIMAGE2D); }
+"uimage2D" { return ES2_ident_ES3_reserved_ES3_1_keyword(context, UIMAGE2D); }
+"image2DArray" { return ES2_ident_ES3_reserved_ES3_1_keyword(context, IMAGE2DARRAY); }
+"iimage2DArray" { return ES2_ident_ES3_reserved_ES3_1_keyword(context, IIMAGE2DARRAY); }
+"uimage2DArray" { return ES2_ident_ES3_reserved_ES3_1_keyword(context, UIMAGE2DARRAY); }
+"image3D"  { return ES2_ident_ES3_reserved_ES3_1_keyword(context, IMAGE3D); }
+"uimage3D" { return ES2_ident_ES3_reserved_ES3_1_keyword(context, UIMAGE3D); }
+"iimage3D" { return ES2_ident_ES3_reserved_ES3_1_keyword(context, IIMAGE3D); }
+"iimageCube" { return ES2_ident_ES3_reserved_ES3_1_keyword(context, IIMAGECUBE); }
+"uimageCube" { return ES2_ident_ES3_reserved_ES3_1_keyword(context, UIMAGECUBE); }
+"imageCube"	{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, IMAGECUBE); }
+"readonly" { return ES2_ident_ES3_reserved_ES3_1_keyword(context, READONLY); }
+"writeonly" { return ES2_ident_ES3_reserved_ES3_1_keyword(context, WRITEONLY); }
+
     /* Reserved keywords for GLSL ES 3.00 that are not reserved for GLSL ES 1.00 */
 "coherent"          |
 "restrict"          |
-"readonly"          |
-"writeonly"         |
 "resource"          |
 "atomic_uint"       |
 "noperspective"     |
@@ -204,23 +218,11 @@ O           [0-7]
 
 "filter"            |
 "image1D"           |
-"image2D"           |
-"image3D"           |
-"imageCube"	        |
 "iimage1D"          |
-"iimage2D"          |
-"iimage3D"          |
-"iimageCube"        |
 "uimage1D"          |
-"uimage2D"          |
-"uimage3D"          |
-"uimageCube"        |
 "image1DArray"      |
-"image2DArray"      |
 "iimage1DArray"     |
-"iimage2DArray"     |
 "uimage1DArray"     |
-"uimage2DArray"     |
 "image1DShadow"     |
 "image2DShadow"     |
 "image1DArrayShadow" |
@@ -463,6 +465,24 @@ int ES2_keyword_ES3_reserved(TParseContext *context, int token)
     return token;
 }
 
+int ES2_ident_ES3_reserved_ES3_1_keyword(TParseContext *context, int token)
+{
+    struct yyguts_t* yyg = (struct yyguts_t*) context->getScanner();
+    yyscan_t yyscanner = (yyscan_t) context->getScanner();
+
+    if (context->getShaderVersion() < 300)
+    {
+        yylval->lex.string = NewPoolTString(yytext);
+        return check_type(yyscanner);
+    }
+    else if (context->getShaderVersion() == 300)
+    {
+        return reserved_word(yyscanner);
+    }
+
+    return token;
+}
+
 int ES2_ident_ES3_keyword(TParseContext *context, int token)
 {
     struct yyguts_t* yyg = (struct yyguts_t*) context->getScanner();

src/compiler/translator/glslang.y

@@ -166,11 +166,14 @@ extern void yyerror(YYLTYPE* yylloc, TParseContext* context, void *scanner, cons
 %token <lex> MATRIX2 MATRIX3 MATRIX4 IN_QUAL OUT_QUAL INOUT_QUAL UNIFORM VARYING
 %token <lex> MATRIX2x3 MATRIX3x2 MATRIX2x4 MATRIX4x2 MATRIX3x4 MATRIX4x3
 %token <lex> CENTROID FLAT SMOOTH
+%token <lex> READONLY WRITEONLY
 %token <lex> STRUCT VOID_TYPE WHILE
 %token <lex> SAMPLER2D SAMPLERCUBE SAMPLER_EXTERNAL_OES SAMPLER2DRECT SAMPLER2DARRAY
 %token <lex> ISAMPLER2D ISAMPLER3D ISAMPLERCUBE ISAMPLER2DARRAY
 %token <lex> USAMPLER2D USAMPLER3D USAMPLERCUBE USAMPLER2DARRAY
 %token <lex> SAMPLER3D SAMPLER3DRECT SAMPLER2DSHADOW SAMPLERCUBESHADOW SAMPLER2DARRAYSHADOW
+%token <lex> IMAGE2D IIMAGE2D UIMAGE2D IMAGE3D IIMAGE3D UIMAGE3D IMAGE2DARRAY IIMAGE2DARRAY UIMAGE2DARRAY
+%token <lex> IMAGECUBE IIMAGECUBE UIMAGECUBE
 %token <lex> LAYOUT
 
 %token <lex> IDENTIFIER TYPE_NAME FLOATCONSTANT INTCONSTANT UINTCONSTANT BOOLCONSTANT
@@ -215,8 +218,8 @@ extern void yyerror(YYLTYPE* yylloc, TParseContext* context, void *scanner, cons
 
 %type <interm.precision> precision_qualifier
 %type <interm.layoutQualifier> layout_qualifier
-%type <interm.qualifier> storage_qualifier interpolation_qualifier
-%type <interm.qualifierWrapper> single_type_qualifier invariant_qualifier
+%type <interm.qualifier> interpolation_qualifier
+%type <interm.qualifierWrapper> storage_qualifier single_type_qualifier invariant_qualifier
 %type <interm.typeQualifierBuilder> type_qualifier
 
 %type <interm.typeSpecifierNonArray> type_specifier_nonarray struct_specifier
@@ -854,11 +857,8 @@ invariant_qualifier
 
 single_type_qualifier
     : storage_qualifier {
-        if (!context->declaringFunction() && $1 != EvqConst && !context->symbolTable.atGlobalLevel())
-        {
-            context->error(@1, "Local variables can only use the const storage qualifier.", getQualifierString($1));
-        }
-        $$ = new TStorageQualifierWrapper($1, @1);
+        context->checkLocalVariableConstStorageQualifier(*$1);
+        $$ = $1;
     }
     | layout_qualifier {
         context->checkIsAtGlobalLevel(@1, "layout");
@@ -883,43 +883,43 @@ storage_qualifier
         VERTEX_ONLY("attribute", @1);
         ES2_ONLY("attribute", @1);
         context->checkIsAtGlobalLevel(@1, "attribute");
-        $$ = EvqAttribute;
+        $$ = new TStorageQualifierWrapper(EvqAttribute, @1);
     }
     | VARYING {
         ES2_ONLY("varying", @1);
         context->checkIsAtGlobalLevel(@1, "varying");
         if (context->getShaderType() == GL_VERTEX_SHADER)
-            $$ = EvqVaryingOut;
+            $$ = new TStorageQualifierWrapper(EvqVaryingOut, @1);
         else
-            $$ = EvqVaryingIn;
+            $$ = new TStorageQualifierWrapper(EvqVaryingIn, @1);
     }
     | CONST_QUAL {
-        $$ = EvqConst;
+        $$ = new TStorageQualifierWrapper(EvqConst, @1);
     }
     | IN_QUAL {
         if (context->declaringFunction())
         {
-            $$ = EvqIn;
+            $$ = new TStorageQualifierWrapper(EvqIn, @1);
         }
         else if (context->getShaderType() == GL_FRAGMENT_SHADER)
         {
             ES3_OR_NEWER("in", @1, "storage qualifier");
-            $$ = EvqFragmentIn;
+            $$ = new TStorageQualifierWrapper(EvqFragmentIn, @1);
         }
         else if (context->getShaderType() == GL_VERTEX_SHADER)
         {
             ES3_OR_NEWER("in", @1, "storage qualifier");
-            $$ = EvqVertexIn;
+            $$ = new TStorageQualifierWrapper(EvqVertexIn, @1);
         }
         else
         {
-            $$ = EvqComputeIn;
+            $$ = new TStorageQualifierWrapper(EvqComputeIn, @1);
         }
     }
     | OUT_QUAL {
         if (context->declaringFunction())
         {
-            $$ = EvqOut;
+            $$ = new TStorageQualifierWrapper(EvqOut, @1);
         }
         else
         {
@@ -927,11 +927,11 @@ storage_qualifier
             NON_COMPUTE_ONLY("out", @1);
             if (context->getShaderType() == GL_FRAGMENT_SHADER)
             {
-                $$ = EvqFragmentOut;
+                $$ = new TStorageQualifierWrapper(EvqFragmentOut, @1);
             }
             else
             {
-                $$ = EvqVertexOut;
+                $$ = new TStorageQualifierWrapper(EvqVertexOut, @1);
             }
         }
     }
@@ -940,15 +940,21 @@ storage_qualifier
         {
             context->error(@1, "invalid inout qualifier", "'inout' can be only used with function parameters");
         }
-        $$ = EvqInOut;
+        $$ = new TStorageQualifierWrapper(EvqInOut, @1);
     }
     | CENTROID {
         ES3_OR_NEWER("centroid", @1, "storage qualifier");
-        $$ = EvqCentroid;
+        $$ = new TStorageQualifierWrapper(EvqCentroid, @1);
     }
     | UNIFORM {
         context->checkIsAtGlobalLevel(@1, "uniform");
-        $$ = EvqUniform;
+        $$ = new TStorageQualifierWrapper(EvqUniform, @1);
+    }
+    | READONLY {
+        $$ = new TMemoryQualifierWrapper(EvqReadOnly, @1);
+    }
+    | WRITEONLY {
+        $$ = new TMemoryQualifierWrapper(EvqWriteOnly, @1);
     }
     ;
 
@@ -1182,6 +1188,42 @@ type_specifier_nonarray
     | struct_specifier {
         $$ = $1;
     }
+    | IMAGE2D {
+        $$.initialize(EbtImage2D, @1);
+    }
+    | IIMAGE2D {
+        $$.initialize(EbtIImage2D, @1);
+    }
+    | UIMAGE2D {
+        $$.initialize(EbtUImage2D, @1);
+    }
+    | IMAGE3D {
+        $$.initialize(EbtImage3D, @1);
+    }
+    | IIMAGE3D {
+        $$.initialize(EbtIImage3D, @1);
+    }
+    | UIMAGE3D {
+        $$.initialize(EbtUImage3D, @1);
+    }
+    | IMAGE2DARRAY {
+        $$.initialize(EbtImage2DArray, @1);
+    }
+    | IIMAGE2DARRAY {
+        $$.initialize(EbtIImage2DArray, @1);
+    }
+    | UIMAGE2DARRAY {
+        $$.initialize(EbtUImage2DArray, @1);
+    }
+    | IMAGECUBE {
+        $$.initialize(EbtImageCube, @1);
+    }
+    | IIMAGECUBE {
+        $$.initialize(EbtIImageCube, @1);
+    }
+    | UIMAGECUBE {
+        $$.initialize(EbtUImageCube, @1);
+    }
     | TYPE_NAME {
         //
         // This is for user defined type names.  The lexical phase looked up the

src/compiler/translator/glslang_tab.h

@@ -50,134 +50,148 @@ extern int yydebug;
 /* Token type.  */
 #ifndef YYTOKENTYPE
 # define YYTOKENTYPE
-  enum yytokentype
-  {
-    INVARIANT = 258,
-    HIGH_PRECISION = 259,
-    MEDIUM_PRECISION = 260,
-    LOW_PRECISION = 261,
-    PRECISION = 262,
-    ATTRIBUTE = 263,
-    CONST_QUAL = 264,
-    BOOL_TYPE = 265,
-    FLOAT_TYPE = 266,
-    INT_TYPE = 267,
-    UINT_TYPE = 268,
-    BREAK = 269,
-    CONTINUE = 270,
-    DO = 271,
-    ELSE = 272,
-    FOR = 273,
-    IF = 274,
-    DISCARD = 275,
-    RETURN = 276,
-    SWITCH = 277,
-    CASE = 278,
-    DEFAULT = 279,
-    BVEC2 = 280,
-    BVEC3 = 281,
-    BVEC4 = 282,
-    IVEC2 = 283,
-    IVEC3 = 284,
-    IVEC4 = 285,
-    VEC2 = 286,
-    VEC3 = 287,
-    VEC4 = 288,
-    UVEC2 = 289,
-    UVEC3 = 290,
-    UVEC4 = 291,
-    MATRIX2 = 292,
-    MATRIX3 = 293,
-    MATRIX4 = 294,
-    IN_QUAL = 295,
-    OUT_QUAL = 296,
-    INOUT_QUAL = 297,
-    UNIFORM = 298,
-    VARYING = 299,
-    MATRIX2x3 = 300,
-    MATRIX3x2 = 301,
-    MATRIX2x4 = 302,
-    MATRIX4x2 = 303,
-    MATRIX3x4 = 304,
-    MATRIX4x3 = 305,
-    CENTROID = 306,
-    FLAT = 307,
-    SMOOTH = 308,
-    STRUCT = 309,
-    VOID_TYPE = 310,
-    WHILE = 311,
-    SAMPLER2D = 312,
-    SAMPLERCUBE = 313,
-    SAMPLER_EXTERNAL_OES = 314,
-    SAMPLER2DRECT = 315,
-    SAMPLER2DARRAY = 316,
-    ISAMPLER2D = 317,
-    ISAMPLER3D = 318,
-    ISAMPLERCUBE = 319,
-    ISAMPLER2DARRAY = 320,
-    USAMPLER2D = 321,
-    USAMPLER3D = 322,
-    USAMPLERCUBE = 323,
-    USAMPLER2DARRAY = 324,
-    SAMPLER3D = 325,
-    SAMPLER3DRECT = 326,
-    SAMPLER2DSHADOW = 327,
-    SAMPLERCUBESHADOW = 328,
-    SAMPLER2DARRAYSHADOW = 329,
-    LAYOUT = 330,
-    IDENTIFIER = 331,
-    TYPE_NAME = 332,
-    FLOATCONSTANT = 333,
-    INTCONSTANT = 334,
-    UINTCONSTANT = 335,
-    BOOLCONSTANT = 336,
-    FIELD_SELECTION = 337,
-    LEFT_OP = 338,
-    RIGHT_OP = 339,
-    INC_OP = 340,
-    DEC_OP = 341,
-    LE_OP = 342,
-    GE_OP = 343,
-    EQ_OP = 344,
-    NE_OP = 345,
-    AND_OP = 346,
-    OR_OP = 347,
-    XOR_OP = 348,
-    MUL_ASSIGN = 349,
-    DIV_ASSIGN = 350,
-    ADD_ASSIGN = 351,
-    MOD_ASSIGN = 352,
-    LEFT_ASSIGN = 353,
-    RIGHT_ASSIGN = 354,
-    AND_ASSIGN = 355,
-    XOR_ASSIGN = 356,
-    OR_ASSIGN = 357,
-    SUB_ASSIGN = 358,
-    LEFT_PAREN = 359,
-    RIGHT_PAREN = 360,
-    LEFT_BRACKET = 361,
-    RIGHT_BRACKET = 362,
-    LEFT_BRACE = 363,
-    RIGHT_BRACE = 364,
-    DOT = 365,
-    COMMA = 366,
-    COLON = 367,
-    EQUAL = 368,
-    SEMICOLON = 369,
-    BANG = 370,
-    DASH = 371,
-    TILDE = 372,
-    PLUS = 373,
-    STAR = 374,
-    SLASH = 375,
-    PERCENT = 376,
-    LEFT_ANGLE = 377,
-    RIGHT_ANGLE = 378,
-    VERTICAL_BAR = 379,
-    CARET = 380,
-    AMPERSAND = 381,
-    QUESTION = 382
-  };
+enum yytokentype
+{
+    INVARIANT            = 258,
+    HIGH_PRECISION       = 259,
+    MEDIUM_PRECISION     = 260,
+    LOW_PRECISION        = 261,
+    PRECISION            = 262,
+    ATTRIBUTE            = 263,
+    CONST_QUAL           = 264,
+    BOOL_TYPE            = 265,
+    FLOAT_TYPE           = 266,
+    INT_TYPE             = 267,
+    UINT_TYPE            = 268,
+    BREAK                = 269,
+    CONTINUE             = 270,
+    DO                   = 271,
+    ELSE                 = 272,
+    FOR                  = 273,
+    IF                   = 274,
+    DISCARD              = 275,
+    RETURN               = 276,
+    SWITCH               = 277,
+    CASE                 = 278,
+    DEFAULT              = 279,
+    BVEC2                = 280,
+    BVEC3                = 281,
+    BVEC4                = 282,
+    IVEC2                = 283,
+    IVEC3                = 284,
+    IVEC4                = 285,
+    VEC2                 = 286,
+    VEC3                 = 287,
+    VEC4                 = 288,
+    UVEC2                = 289,
+    UVEC3                = 290,
+    UVEC4                = 291,
+    MATRIX2              = 292,
+    MATRIX3              = 293,
+    MATRIX4              = 294,
+    IN_QUAL              = 295,
+    OUT_QUAL             = 296,
+    INOUT_QUAL           = 297,
+    UNIFORM              = 298,
+    VARYING              = 299,
+    MATRIX2x3            = 300,
+    MATRIX3x2            = 301,
+    MATRIX2x4            = 302,
+    MATRIX4x2            = 303,
+    MATRIX3x4            = 304,
+    MATRIX4x3            = 305,
+    CENTROID             = 306,
+    FLAT                 = 307,
+    SMOOTH               = 308,
+    READONLY             = 309,
+    WRITEONLY            = 310,
+    STRUCT               = 311,
+    VOID_TYPE            = 312,
+    WHILE                = 313,
+    SAMPLER2D            = 314,
+    SAMPLERCUBE          = 315,
+    SAMPLER_EXTERNAL_OES = 316,
+    SAMPLER2DRECT        = 317,
+    SAMPLER2DARRAY       = 318,
+    ISAMPLER2D           = 319,
+    ISAMPLER3D           = 320,
+    ISAMPLERCUBE         = 321,
+    ISAMPLER2DARRAY      = 322,
+    USAMPLER2D           = 323,
+    USAMPLER3D           = 324,
+    USAMPLERCUBE         = 325,
+    USAMPLER2DARRAY      = 326,
+    SAMPLER3D            = 327,
+    SAMPLER3DRECT        = 328,
+    SAMPLER2DSHADOW      = 329,
+    SAMPLERCUBESHADOW    = 330,
+    SAMPLER2DARRAYSHADOW = 331,
+    IMAGE2D              = 332,
+    IIMAGE2D             = 333,
+    UIMAGE2D             = 334,
+    IMAGE3D              = 335,
+    IIMAGE3D             = 336,
+    UIMAGE3D             = 337,
+    IMAGE2DARRAY         = 338,
+    IIMAGE2DARRAY        = 339,
+    UIMAGE2DARRAY        = 340,
+    IMAGECUBE            = 341,
+    IIMAGECUBE           = 342,
+    UIMAGECUBE           = 343,
+    LAYOUT               = 344,
+    IDENTIFIER           = 345,
+    TYPE_NAME            = 346,
+    FLOATCONSTANT        = 347,
+    INTCONSTANT          = 348,
+    UINTCONSTANT         = 349,
+    BOOLCONSTANT         = 350,
+    FIELD_SELECTION      = 351,
+    LEFT_OP              = 352,
+    RIGHT_OP             = 353,
+    INC_OP               = 354,
+    DEC_OP               = 355,
+    LE_OP                = 356,
+    GE_OP                = 357,
+    EQ_OP                = 358,
+    NE_OP                = 359,
+    AND_OP               = 360,
+    OR_OP                = 361,
+    XOR_OP               = 362,
+    MUL_ASSIGN           = 363,
+    DIV_ASSIGN           = 364,
+    ADD_ASSIGN           = 365,
+    MOD_ASSIGN           = 366,
+    LEFT_ASSIGN          = 367,
+    RIGHT_ASSIGN         = 368,
+    AND_ASSIGN           = 369,
+    XOR_ASSIGN           = 370,
+    OR_ASSIGN            = 371,
+    SUB_ASSIGN           = 372,
+    LEFT_PAREN           = 373,
+    RIGHT_PAREN          = 374,
+    LEFT_BRACKET         = 375,
+    RIGHT_BRACKET        = 376,
+    LEFT_BRACE           = 377,
+    RIGHT_BRACE          = 378,
+    DOT                  = 379,
+    COMMA                = 380,
+    COLON                = 381,
+    EQUAL                = 382,
+    SEMICOLON            = 383,
+    BANG                 = 384,
+    DASH                 = 385,
+    TILDE                = 386,
+    PLUS                 = 387,
+    STAR                 = 388,
+    SLASH                = 389,
+    PERCENT              = 390,
+    LEFT_ANGLE           = 391,
+    RIGHT_ANGLE          = 392,
+    VERTICAL_BAR         = 393,
+    CARET                = 394,
+    AMPERSAND            = 395,
+    QUESTION             = 396
+};
 #endif
 
 /* Value type.  */
@@ -204,6 +218,7 @@ union YYSTYPE
             TIntermNodePair nodePair;
             TIntermTyped* intermTypedNode;
             TIntermAggregate* intermAggregate;
+            TIntermBlock *intermBlock;
             TIntermSwitch* intermSwitch;
             TIntermCase* intermCase;
         };

src/compiler/translator/util.cpp

@@ -159,6 +159,30 @@ GLenum GLVariableType(const TType &type)
       case EbtSampler2DShadow:      return GL_SAMPLER_2D_SHADOW;
       case EbtSamplerCubeShadow:    return GL_SAMPLER_CUBE_SHADOW;
       case EbtSampler2DArrayShadow: return GL_SAMPLER_2D_ARRAY_SHADOW;
+      case EbtImage2D:
+          return GL_IMAGE_2D;
+      case EbtIImage2D:
+          return GL_INT_IMAGE_2D;
+      case EbtUImage2D:
+          return GL_UNSIGNED_INT_IMAGE_2D;
+      case EbtImage2DArray:
+          return GL_IMAGE_2D_ARRAY;
+      case EbtIImage2DArray:
+          return GL_INT_IMAGE_2D_ARRAY;
+      case EbtUImage2DArray:
+          return GL_UNSIGNED_INT_IMAGE_2D_ARRAY;
+      case EbtImage3D:
+          return GL_IMAGE_3D;
+      case EbtIImage3D:
+          return GL_INT_IMAGE_3D;
+      case EbtUImage3D:
+          return GL_UNSIGNED_INT_IMAGE_3D;
+      case EbtImageCube:
+          return GL_IMAGE_CUBE;
+      case EbtIImageCube:
+          return GL_INT_IMAGE_CUBE;
+      case EbtUImageCube:
+          return GL_UNSIGNED_INT_IMAGE_CUBE;
       default: UNREACHABLE();
     }
 

src/tests/angle_unittests.gypi

@@ -61,6 +61,7 @@
             '<(angle_path)/src/tests/compiler_tests/RecordConstantPrecision_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/RemovePow_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/ShaderExtension_test.cpp',
+            '<(angle_path)/src/tests/compiler_tests/ShaderImage_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/ShaderVariable_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/ShCompile_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/TypeTracking_test.cpp',

src/tests/compiler_tests/ShaderImage_test.cpp

+//
+// Copyright (c) 2016 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// ShaderImage_test.cpp:
+// Tests for images
+//
+
+#include "angle_gl.h"
+#include "gtest/gtest.h"
+#include "GLSLANG/ShaderLang.h"
+#include "compiler/translator/TranslatorESSL.h"
+#include "tests/test_utils/compiler_test.h"
+
+namespace
+{
+
+// Checks that the imageStore call with mangled name imageStoreMangledName exists in the AST.
+// Further each argument is checked whether it matches the expected properties given the compiled
+// shader.
+void CheckImageStoreCall(TIntermNode *astRoot,
+                         const TString &imageStoreMangledName,
+                         TBasicType imageType,
+                         int storeLocationNominalSize,
+                         TBasicType storeValueType,
+                         int storeValueNominalSize)
+{
+    const TIntermAggregate *imageStoreFunctionCall =
+        FindFunctionCallNode(astRoot, imageStoreMangledName);
+    ASSERT_NE(nullptr, imageStoreFunctionCall);
+
+    const TIntermSequence *storeArguments = imageStoreFunctionCall->getSequence();
+    ASSERT_EQ(3u, storeArguments->size());
+
+    const TIntermTyped *storeArgument1Typed = (*storeArguments)[0]->getAsTyped();
+    ASSERT_EQ(imageType, storeArgument1Typed->getBasicType());
+
+    const TIntermTyped *storeArgument2Typed = (*storeArguments)[1]->getAsTyped();
+    ASSERT_EQ(EbtInt, storeArgument2Typed->getBasicType());
+    ASSERT_EQ(storeLocationNominalSize, storeArgument2Typed->getNominalSize());
+
+    const TIntermTyped *storeArgument3Typed = (*storeArguments)[2]->getAsTyped();
+    ASSERT_EQ(storeValueType, storeArgument3Typed->getBasicType());
+    ASSERT_EQ(storeValueNominalSize, storeArgument3Typed->getNominalSize());
+}
+
+// Checks that the imageLoad call with mangled name imageLoadMangledName exists in the AST.
+// Further each argument is checked whether it matches the expected properties given the compiled
+// shader.
+void CheckImageLoadCall(TIntermNode *astRoot,
+                        const TString &imageLoadMangledName,
+                        TBasicType imageType,
+                        int loadLocationNominalSize)
+{
+    const TIntermAggregate *imageLoadFunctionCall =
+        FindFunctionCallNode(astRoot, imageLoadMangledName);
+    ASSERT_NE(nullptr, imageLoadFunctionCall);
+
+    const TIntermSequence *loadArguments = imageLoadFunctionCall->getSequence();
+    ASSERT_EQ(2u, loadArguments->size());
+
+    const TIntermTyped *loadArgument1Typed = (*loadArguments)[0]->getAsTyped();
+    ASSERT_EQ(imageType, loadArgument1Typed->getBasicType());
+
+    const TIntermTyped *loadArgument2Typed = (*loadArguments)[1]->getAsTyped();
+    ASSERT_EQ(EbtInt, loadArgument2Typed->getBasicType());
+    ASSERT_EQ(loadLocationNominalSize, loadArgument2Typed->getNominalSize());
+}
+
+// Checks whether the image is properly exported as a uniform by the compiler.
+void CheckExportedImageUniform(const std::vector<sh::Uniform> &uniforms,
+                               size_t uniformIndex,
+                               GLenum imageTypeGL,
+                               const TString &imageName)
+{
+    ASSERT_EQ(1u, uniforms.size());
+
+    const auto &imageUniform = uniforms[uniformIndex];
+    ASSERT_EQ(imageTypeGL, imageUniform.type);
+    ASSERT_STREQ(imageUniform.name.c_str(), imageName.c_str());
+}
+
+// Checks whether the image is saved in the AST as a node with the correct properties given the
+// shader.
+void CheckImageDeclaration(TIntermNode *astRoot,
+                           const TString &imageName,
+                           TBasicType imageType,
+                           TLayoutImageInternalFormat internalFormat,
+                           bool readonly,
+                           bool writeonly)
+{
+    const TIntermSymbol *myImageNode = FindSymbolNode(astRoot, imageName, imageType);
+    ASSERT_NE(nullptr, myImageNode);
+
+    const TType &myImageType                = myImageNode->getType();
+    TLayoutQualifier myImageLayoutQualifier = myImageType.getLayoutQualifier();
+    ASSERT_EQ(internalFormat, myImageLayoutQualifier.imageInternalFormat);
+    TMemoryQualifier myImageMemoryQualifier = myImageType.getMemoryQualifier();
+    ASSERT_EQ(readonly, myImageMemoryQualifier.readonly);
+    ASSERT_EQ(writeonly, myImageMemoryQualifier.writeonly);
+}
+
+}  // namespace
+
+class ShaderImageTest : public testing::Test
+{
+  public:
+    ShaderImageTest() {}
+
+  protected:
+    virtual void SetUp()
+    {
+        ShBuiltInResources resources;
+        ShInitBuiltInResources(&resources);
+
+        mTranslator = new TranslatorESSL(GL_COMPUTE_SHADER, SH_GLES3_1_SPEC);
+        ASSERT_TRUE(mTranslator->Init(resources));
+    }
+
+    virtual void TearDown() { delete mTranslator; }
+
+    // Return true when compilation succeeds
+    bool compile(const std::string &shaderString)
+    {
+        const char *shaderStrings[] = {shaderString.c_str()};
+        mASTRoot                    = mTranslator->compileTreeForTesting(shaderStrings, 1,
+                                                      SH_INTERMEDIATE_TREE | SH_VARIABLES);
+        TInfoSink &infoSink = mTranslator->getInfoSink();
+        mInfoLog            = infoSink.info.c_str();
+        return mASTRoot != nullptr;
+    }
+
+  protected:
+    std::string mTranslatedCode;
+    std::string mInfoLog;
+    TranslatorESSL *mTranslator;
+    TIntermNode *mASTRoot;
+};
+
+// Test that an image2D is properly parsed and exported as a uniform.
+TEST_F(ShaderImageTest, Image2DDeclaration)
+{
+    const std::string &shaderString =
+        "#version 310 es\n"
+        "layout(local_size_x = 4) in;\n"
+        "layout(rgba32f) uniform highp readonly image2D myImage;\n"
+        "void main() {\n"
+        "   ivec2 sz = imageSize(myImage);\n"
+        "}";
+    if (!compile(shaderString))
+    {
+        FAIL() << "Shader compilation failed" << mInfoLog;
+    }
+
+    CheckExportedImageUniform(mTranslator->getUniforms(), 0, GL_IMAGE_2D, "myImage");
+    CheckImageDeclaration(mASTRoot, "myImage", EbtImage2D, EiifRGBA32F, true, false);
+}
+
+// Test that an image3D is properly parsed and exported as a uniform.
+TEST_F(ShaderImageTest, Image3DDeclaration)
+{
+    const std::string &shaderString =
+        "#version 310 es\n"
+        "layout(local_size_x = 4) in;\n"
+        "layout(rgba32ui) uniform highp writeonly readonly uimage3D myImage;\n"
+        "void main() {\n"
+        "   ivec3 sz = imageSize(myImage);\n"
+        "}";
+    if (!compile(shaderString))
+    {
+        FAIL() << "Shader compilation failed" << mInfoLog;
+    }
+
+    CheckExportedImageUniform(mTranslator->getUniforms(), 0, GL_UNSIGNED_INT_IMAGE_3D, "myImage");
+    CheckImageDeclaration(mASTRoot, "myImage", EbtUImage3D, EiifRGBA32UI, true, true);
+}
+
+// Check that imageLoad calls get correctly parsed.
+TEST_F(ShaderImageTest, ImageLoad)
+{
+    const std::string &shaderString =
+        "#version 310 es\n"
+        "layout(local_size_x = 4) in;\n"
+        "layout(rgba32f) uniform highp readonly image2D my2DImageInput;\n"
+        "layout(rgba32i) uniform highp readonly iimage3D my3DImageInput;\n"
+        "void main() {\n"
+        "   vec4 result = imageLoad(my2DImageInput, ivec2(gl_LocalInvocationID.xy));\n"
+        "   ivec4 result2 = imageLoad(my3DImageInput, ivec3(gl_LocalInvocationID.xyz));\n"
+        "}";
+    if (!compile(shaderString))
+    {
+        FAIL() << "Shader compilation failed" << mInfoLog;
+    }
+
+    // imageLoad call with image2D passed
+    CheckImageLoadCall(mASTRoot, "imageLoad(im21;vi2;", EbtImage2D, 2);
+
+    // imageLoad call with image3D passed
+    CheckImageLoadCall(mASTRoot, "imageLoad(iim31;vi3;", EbtIImage3D, 3);
+}
+
+// Check that imageStore calls get correctly parsed.
+TEST_F(ShaderImageTest, ImageStore)
+{
+    const std::string &shaderString =
+        "#version 310 es\n"
+        "layout(local_size_x = 4) in;\n"
+        "layout(rgba32f) uniform highp writeonly image2D my2DImageOutput;\n"
+        "layout(rgba32ui) uniform highp writeonly uimage2DArray my2DImageArrayOutput;\n"
+        "void main() {\n"
+        "   imageStore(my2DImageOutput, ivec2(gl_LocalInvocationID.xy), vec4(0.0));\n"
+        "   imageStore(my2DImageArrayOutput, ivec3(gl_LocalInvocationID.xyz), uvec4(0));\n"
+        "}";
+    if (!compile(shaderString))
+    {
+        FAIL() << "Shader compilation failed" << mInfoLog;
+    }
+
+    // imageStore call with image2D
+    CheckImageStoreCall(mASTRoot, "imageStore(im21;vi2;vf4;", EbtImage2D, 2, EbtFloat, 4);
+
+    // imageStore call with image2DArray
+    CheckImageStoreCall(mASTRoot, "imageStore(uim2a1;vi3;vu4;", EbtUImage2DArray, 3, EbtUInt, 4);
+}

src/tests/test_utils/compiler_test.cpp

@@ -42,6 +42,33 @@ class ShaderVariableFinder : public TIntermTraverser
     TBasicType mBasicType;
 };
 
+class FunctionCallFinder : public TIntermTraverser
+{
+  public:
+    FunctionCallFinder(const TString &functionName)
+        : TIntermTraverser(true, false, false), mFunctionName(functionName), mNodeFound(nullptr)
+    {
+    }
+
+    bool visitAggregate(Visit visit, TIntermAggregate *node) override
+    {
+        if (node->getOp() == EOpFunctionCall &&
+            node->getFunctionSymbolInfo()->getName() == mFunctionName)
+        {
+            mNodeFound = node;
+            return false;
+        }
+        return true;
+    }
+
+    bool isFound() const { return mNodeFound != nullptr; }
+    const TIntermAggregate *getNode() const { return mNodeFound; }
+
+  private:
+    TString mFunctionName;
+    TIntermAggregate *mNodeFound;
+};
+
 }  // anonymous namespace
 
 bool compileTestShader(GLenum type,
@@ -215,3 +242,10 @@ const TIntermSymbol *FindSymbolNode(TIntermNode *root,
     root->traverse(&finder);
     return finder.getNode();
 }
+
+const TIntermAggregate *FindFunctionCallNode(TIntermNode *root, const TString &functionName)
+{
+    FunctionCallFinder finder(functionName);
+    root->traverse(&finder);
+    return finder.getNode();
+}

src/tests/test_utils/compiler_test.h

@@ -93,4 +93,7 @@ const TIntermSymbol *FindSymbolNode(TIntermNode *root,
                                     const TString &symbolName,
                                     TBasicType basicType);
 
+// Returns a pointer to a function call node with a mangled name functionName.
+const TIntermAggregate *FindFunctionCallNode(TIntermNode *root, const TString &functionName);
+
 #endif // TESTS_TEST_UTILS_COMPILER_TEST_H_