Merge pull request #1431 from KhronosGroup/implement-8-16-bit-storage

SPIRV/GLSL.ext.KHR.h

@@ -36,6 +36,7 @@ static const char* const E_SPV_KHR_device_group                 = "SPV_KHR_devic
 static const char* const E_SPV_KHR_multiview                    = "SPV_KHR_multiview";
 static const char* const E_SPV_KHR_shader_draw_parameters       = "SPV_KHR_shader_draw_parameters";
 static const char* const E_SPV_KHR_16bit_storage                = "SPV_KHR_16bit_storage";
+static const char* const E_SPV_KHR_8bit_storage                 = "SPV_KHR_8bit_storage";
 static const char* const E_SPV_KHR_storage_buffer_storage_class = "SPV_KHR_storage_buffer_storage_class";
 static const char* const E_SPV_KHR_post_depth_coverage          = "SPV_KHR_post_depth_coverage";
 

SPIRV/GlslangToSpv.cpp

@@ -2507,6 +2507,20 @@ spv::Id TGlslangToSpvTraverser::createSpvVariable(const glslang::TIntermSymbol*
         }
     }
 
+    const bool contains8BitType = node->getType().containsBasicType(glslang::EbtInt8)   ||
+                                  node->getType().containsBasicType(glslang::EbtUint8);
+    if (contains8BitType) {
+        if (storageClass == spv::StorageClassPushConstant) {
+            builder.addExtension(spv::E_SPV_KHR_8bit_storage);
+            builder.addCapability(spv::CapabilityStoragePushConstant8);
+        } else if (storageClass == spv::StorageClassUniform) {
+            builder.addExtension(spv::E_SPV_KHR_8bit_storage);
+            builder.addCapability(spv::CapabilityUniformAndStorageBuffer8BitAccess);
+            if (node->getType().getQualifier().storage == glslang::EvqBuffer)
+                builder.addCapability(spv::CapabilityStorageBuffer8BitAccess);
+        }
+    }
+
     const char* name = node->getName().c_str();
     if (glslang::IsAnonymous(name))
         name = "";

SPIRV/doc.cpp

@@ -790,6 +790,10 @@ const char* CapabilityString(int info)
     case CapabilityStoragePushConstant16:       return "StoragePushConstant16";
     case CapabilityStorageInputOutput16:        return "StorageInputOutput16";
 
+    case CapabilityStorageBuffer8BitAccess:             return "CapabilityStorageBuffer8BitAccess";
+    case CapabilityUniformAndStorageBuffer8BitAccess:   return "CapabilityUniformAndStorageBuffer8BitAccess";
+    case CapabilityStoragePushConstant8:                return "CapabilityStoragePushConstant8";
+
     case CapabilityDeviceGroup: return "DeviceGroup";
     case CapabilityMultiView:   return "MultiView";
 

SPIRV/spirv.hpp

@@ -679,6 +679,9 @@ enum Capability {
     CapabilityVariablePointers = 4442,
     CapabilityAtomicStorageOps = 4445,
     CapabilitySampleMaskPostDepthCoverage = 4447,
+    CapabilityStorageBuffer8BitAccess = 4448,
+    CapabilityUniformAndStorageBuffer8BitAccess = 4449,
+    CapabilityStoragePushConstant8 = 4450,
     CapabilityFloat16ImageAMD = 5008,
     CapabilityImageGatherBiasLodAMD = 5009,
     CapabilityFragmentMaskAMD = 5010,

Test/baseResults/120.frag.out

@@ -56,9 +56,8 @@ ERROR: 0:248: 'explicit types' : required extension not requested: Possible exte
 GL_AMD_gpu_shader_half_float
 GL_KHX_shader_explicit_arithmetic_types
 GL_KHX_shader_explicit_arithmetic_types_float16
-ERROR: 0:248: 'half floating-point suffix' : not supported with this profile: none
 ERROR: 0:248: '' :  syntax error, unexpected IDENTIFIER, expecting COMMA or SEMICOLON
-ERROR: 56 compilation errors.  No code generated.
+ERROR: 55 compilation errors.  No code generated.
 
 
 Shader version: 120

Test/baseResults/spv.16bitstorage_Error-int.frag.out

+spv.16bitstorage_Error-int.frag
+ERROR: 0:54: '(u)int16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:58: 'can't use with structs containing int16' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:61: '(u)int16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:74: ''[' does not operate on types containing (u)int16' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:75: 'can't swizzle types containing (u)int16' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:76: '(u)int16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:76: '(u)int16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:76: '(u)int16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:77: '(u)int16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:77: '(u)int16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:78: '+' :  wrong operand types: no operation '+' exists that takes a left-hand operand of type 'layout( column_major std140 offset=0) uniform int16_t' and a right operand of type 'layout( column_major std140 offset=0) uniform int16_t' (or there is no acceptable conversion)
+ERROR: 0:79: '-' :  wrong operand type no operation '-' exists that takes an operand of type layout( column_major std140 offset=0) uniform int16_t (or there is no acceptable conversion)
+ERROR: 0:80: '+' :  wrong operand types: no operation '+' exists that takes a left-hand operand of type 'layout( column_major std140 offset=0) uniform int16_t' and a right operand of type ' const int' (or there is no acceptable conversion)
+ERROR: 0:81: 'can't swizzle types containing (u)int16' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:82: 'can't use with structs containing int16' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:83: '(u)int16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:84: '(u)int16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:85: '(u)int16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:86: '==' :  wrong operand types: no operation '==' exists that takes a left-hand operand of type 'layout( column_major std140 offset=0) uniform int16_t' and a right operand of type 'layout( column_major std140 offset=0) uniform int16_t' (or there is no acceptable conversion)
+ERROR: 0:87: 'can't use with arrays containing int16' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:88: '16-bit vector constructors only take vector types' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:89: '16-bit array constructors not supported' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:89: '16-bit vector constructors only take vector types' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:92: 'Can't construct structure containing 16-bit type' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:93: 'func2' : no matching overloaded function found 
+ERROR: 0:99: '' :  syntax error, unexpected IDENTIFIER
+ERROR: 26 compilation errors.  No code generated.
+
+
+SPIR-V is not generated for failed compile or link

Test/baseResults/spv.16bitstorage_Error-uint.frag.out

+spv.16bitstorage_Error-uint.frag
+ERROR: 0:54: '(u)int16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:58: 'can't use with structs containing uint16' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:61: '(u)int16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:74: ''[' does not operate on types containing (u)int16' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:75: 'can't swizzle types containing (u)int16' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:76: '(u)int16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:76: '(u)int16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:76: '(u)int16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:77: '(u)int16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:77: '(u)int16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:78: '+' :  wrong operand types: no operation '+' exists that takes a left-hand operand of type 'layout( column_major std140 offset=0) uniform uint16_t' and a right operand of type 'layout( column_major std140 offset=0) uniform uint16_t' (or there is no acceptable conversion)
+ERROR: 0:79: '-' :  wrong operand type no operation '-' exists that takes an operand of type layout( column_major std140 offset=0) uniform uint16_t (or there is no acceptable conversion)
+ERROR: 0:80: '+' :  wrong operand types: no operation '+' exists that takes a left-hand operand of type 'layout( column_major std140 offset=0) uniform uint16_t' and a right operand of type ' const int' (or there is no acceptable conversion)
+ERROR: 0:81: 'can't swizzle types containing (u)int16' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:82: 'can't use with structs containing uint16' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:83: '(u)int16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:84: '(u)int16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:85: '(u)int16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:86: '==' :  wrong operand types: no operation '==' exists that takes a left-hand operand of type 'layout( column_major std140 offset=0) uniform uint16_t' and a right operand of type 'layout( column_major std140 offset=0) uniform uint16_t' (or there is no acceptable conversion)
+ERROR: 0:87: 'can't use with arrays containing uint16' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:88: '16-bit vector constructors only take vector types' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:89: '16-bit array constructors not supported' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:89: '16-bit vector constructors only take vector types' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:92: 'Can't construct structure containing 16-bit type' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_int16
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int16
+ERROR: 0:93: 'func2' : no matching overloaded function found 
+ERROR: 0:99: '' :  syntax error, unexpected IDENTIFIER
+ERROR: 26 compilation errors.  No code generated.
+
+
+SPIR-V is not generated for failed compile or link

Test/baseResults/spv.16bitstorage_Error.frag.out

+spv.16bitstorage_Error.frag
+ERROR: 0:54: 'float16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:58: 'can't use with structs containing float16' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:61: 'float16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:74: ''[' does not operate on types containing float16' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:75: 'can't swizzle types containing float16' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:76: 'float16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:76: 'float16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:76: 'float16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:77: 'float16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:77: 'float16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:78: '+' :  wrong operand types: no operation '+' exists that takes a left-hand operand of type 'layout( column_major std140 offset=0) uniform float16_t' and a right operand of type 'layout( column_major std140 offset=0) uniform float16_t' (or there is no acceptable conversion)
+ERROR: 0:79: '-' :  wrong operand type no operation '-' exists that takes an operand of type layout( column_major std140 offset=0) uniform float16_t (or there is no acceptable conversion)
+ERROR: 0:80: '+' :  wrong operand types: no operation '+' exists that takes a left-hand operand of type 'layout( column_major std140 offset=0) uniform float16_t' and a right operand of type ' const float' (or there is no acceptable conversion)
+ERROR: 0:81: 'can't swizzle types containing float16' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:82: 'can't use with structs containing float16' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:83: 'float16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:84: 'float16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:85: 'float16 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:86: '==' :  wrong operand types: no operation '==' exists that takes a left-hand operand of type 'layout( column_major std140 offset=0) uniform float16_t' and a right operand of type 'layout( column_major std140 offset=0) uniform float16_t' (or there is no acceptable conversion)
+ERROR: 0:87: 'can't use with arrays containing float16' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:88: 'explicit types' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:88: 'explicit types' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:89: '16-bit vector constructors only take vector types' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:90: '16-bit array constructors not supported' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:90: '16-bit vector constructors only take vector types' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:93: 'Can't construct structure containing 16-bit type' : required extension not requested: Possible extensions include:
+GL_AMD_gpu_shader_half_float
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_float16
+ERROR: 0:94: 'func2' : no matching overloaded function found 
+ERROR: 0:100: '' :  syntax error, unexpected IDENTIFIER
+ERROR: 28 compilation errors.  No code generated.
+
+
+SPIR-V is not generated for failed compile or link

Test/baseResults/spv.8bitstorage_Error-int.frag.out

+spv.8bitstorage_Error-int.frag
+ERROR: 0:54: '(u)int8 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:58: 'can't use with structs containing int8' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:61: '(u)int8 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:74: ''[' does not operate on types containing (u)int8' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:75: 'can't swizzle types containing (u)int8' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:76: '(u)int8 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:76: '(u)int8 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:76: '(u)int8 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:77: '(u)int8 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:77: '(u)int8 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:78: '+' :  wrong operand types: no operation '+' exists that takes a left-hand operand of type 'layout( column_major std140 offset=0) uniform int8_t' and a right operand of type 'layout( column_major std140 offset=0) uniform int8_t' (or there is no acceptable conversion)
+ERROR: 0:79: '-' :  wrong operand type no operation '-' exists that takes an operand of type layout( column_major std140 offset=0) uniform int8_t (or there is no acceptable conversion)
+ERROR: 0:80: '+' :  wrong operand types: no operation '+' exists that takes a left-hand operand of type 'layout( column_major std140 offset=0) uniform int8_t' and a right operand of type ' const int' (or there is no acceptable conversion)
+ERROR: 0:81: 'can't swizzle types containing (u)int8' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:82: 'can't use with structs containing int8' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:83: '(u)int8 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:84: '(u)int8 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:85: '(u)int8 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:86: '==' :  wrong operand types: no operation '==' exists that takes a left-hand operand of type 'layout( column_major std140 offset=0) uniform int8_t' and a right operand of type 'layout( column_major std140 offset=0) uniform int8_t' (or there is no acceptable conversion)
+ERROR: 0:87: 'can't use with arrays containing int8' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:88: '8-bit vector constructors only take vector types' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:89: '8-bit array constructors not supported' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:89: '8-bit vector constructors only take vector types' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:92: 'Can't construct structure containing 8-bit type' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:93: 'func2' : no matching overloaded function found 
+ERROR: 0:99: '' :  syntax error, unexpected IDENTIFIER
+ERROR: 26 compilation errors.  No code generated.
+
+
+SPIR-V is not generated for failed compile or link

Test/baseResults/spv.8bitstorage_Error-uint.frag.out

+spv.8bitstorage_Error-uint.frag
+ERROR: 0:54: '(u)int8 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:58: 'can't use with structs containing uint8' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:61: '(u)int8 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:74: ''[' does not operate on types containing (u)int8' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:75: 'can't swizzle types containing (u)int8' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:76: '(u)int8 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:76: '(u)int8 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:76: '(u)int8 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:77: '(u)int8 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:77: '(u)int8 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:78: '+' :  wrong operand types: no operation '+' exists that takes a left-hand operand of type 'layout( column_major std140 offset=0) uniform uint8_t' and a right operand of type 'layout( column_major std140 offset=0) uniform uint8_t' (or there is no acceptable conversion)
+ERROR: 0:79: '-' :  wrong operand type no operation '-' exists that takes an operand of type layout( column_major std140 offset=0) uniform uint8_t (or there is no acceptable conversion)
+ERROR: 0:80: '+' :  wrong operand types: no operation '+' exists that takes a left-hand operand of type 'layout( column_major std140 offset=0) uniform uint8_t' and a right operand of type ' const int' (or there is no acceptable conversion)
+ERROR: 0:81: 'can't swizzle types containing (u)int8' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:82: 'can't use with structs containing uint8' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:83: '(u)int8 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:84: '(u)int8 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:85: '(u)int8 types can only be in uniform block or buffer storage' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:86: '==' :  wrong operand types: no operation '==' exists that takes a left-hand operand of type 'layout( column_major std140 offset=0) uniform uint8_t' and a right operand of type 'layout( column_major std140 offset=0) uniform uint8_t' (or there is no acceptable conversion)
+ERROR: 0:87: 'can't use with arrays containing uint8' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:88: '8-bit vector constructors only take vector types' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:89: '8-bit array constructors not supported' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:89: '8-bit vector constructors only take vector types' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:92: 'Can't construct structure containing 8-bit type' : required extension not requested: Possible extensions include:
+GL_KHX_shader_explicit_arithmetic_types
+GL_KHX_shader_explicit_arithmetic_types_int8
+ERROR: 0:93: 'func2' : no matching overloaded function found 
+ERROR: 0:99: '' :  syntax error, unexpected IDENTIFIER
+ERROR: 26 compilation errors.  No code generated.
+
+
+SPIR-V is not generated for failed compile or link

Test/spv.16bitstorage-int.frag

+#version 450 core
+
+#extension GL_EXT_shader_16bit_storage : enable
+
+struct S
+{
+    int16_t  x;
+    i16vec2    y;
+    i16vec3    z;
+};
+
+layout(column_major, std140) uniform B1
+{
+    int16_t  a;
+    i16vec2    b;
+    i16vec3    c;
+    int16_t  d[2];
+    S          g;
+    S          h[2];
+    int        j;
+} b1;
+
+layout(row_major, std430) buffer B2
+{
+    int16_t  o;
+    i16vec2    p;
+    i16vec3    q;
+    int16_t  r[2];
+    S          u;
+    S          v[2];
+    i16vec2    x[100];
+    int16_t  w[];
+} b2;
+
+layout(row_major, std140) uniform B5
+{
+    int16_t  o;
+    i16vec2    p;
+    i16vec3    q;
+    int16_t  r[2];
+    S          u;
+    S          v[2];
+    i16vec2    x[100];
+    int16_t  w[100];
+} b5;
+
+struct S2 {
+    mat4x4 x;
+    int16_t y;
+    int z;
+};
+
+struct S3 {
+    S2 x;
+};
+
+layout(row_major, std430) buffer B3
+{
+    S2 x;
+} b3;
+
+layout(column_major, std430) buffer B4
+{
+    S2 x;
+    S3 y;
+} b4;
+
+void main()
+{
+    b2.o = b1.a;
+    b2.p = i16vec2(ivec3(b2.q).xy);
+    b2.p = i16vec2(ivec3(b5.q).xy);
+    b2.r[0] = b2.r[0];
+    b2.r[1] = b5.r[1];
+    b2.p = b2.p;
+    int x0 = int(b1.a);
+    ivec4 x1 = ivec4(b1.a, b2.p, 1);
+    b4.x.x = b3.x.x;
+    b2.o = int16_t(ivec2(b2.p).x);
+    b2.p = b2.v[1].y;
+    ivec3 v3 = ivec3(b2.w[b1.j], b2.w[b1.j+1], b2.w[b1.j+2]);
+    ivec3 u3 = ivec3(b5.w[b1.j], b5.w[b1.j+1], b5.w[b1.j+2]);
+    b2.x[0] = b2.x[0];
+    b2.x[1] = b5.x[1];
+    b2.p.x = b1.a;
+    b2.o = b2.p.x;
+    b2.p = i16vec2(ivec2(1, 2));
+    b2.o = int16_t(3);
+}
+

Test/spv.16bitstorage-uint.frag

+#version 450 core
+
+#extension GL_EXT_shader_16bit_storage : enable
+
+struct S
+{
+    uint16_t  x;
+    u16vec2    y;
+    u16vec3    z;
+};
+
+layout(column_major, std140) uniform B1
+{
+    uint16_t  a;
+    u16vec2    b;
+    u16vec3    c;
+    uint16_t  d[2];
+    S          g;
+    S          h[2];
+    uint        j;
+} b1;
+
+layout(row_major, std430) buffer B2
+{
+    uint16_t  o;
+    u16vec2    p;
+    u16vec3    q;
+    uint16_t  r[2];
+    S          u;
+    S          v[2];
+    u16vec2    x[100];
+    uint16_t  w[];
+} b2;
+
+layout(row_major, std140) uniform B5
+{
+    uint16_t  o;
+    u16vec2    p;
+    u16vec3    q;
+    uint16_t  r[2];
+    S          u;
+    S          v[2];
+    u16vec2    x[100];
+    uint16_t  w[100];
+} b5;
+
+struct S2 {
+    mat4x4 x;
+    uint16_t y;
+    uint z;
+};
+
+struct S3 {
+    S2 x;
+};
+
+layout(row_major, std430) buffer B3
+{
+    S2 x;
+} b3;
+
+layout(column_major, std430) buffer B4
+{
+    S2 x;
+    S3 y;
+} b4;
+
+void main()
+{
+    b2.o = b1.a;
+    b2.p = u16vec2(uvec3(b2.q).xy);
+    b2.p = u16vec2(uvec3(b5.q).xy);
+    b2.r[0] = b2.r[0];
+    b2.r[1] = b5.r[1];
+    b2.p = b2.p;
+    uint x0 = uint(b1.a);
+    uvec4 x1 = uvec4(b1.a, b2.p, 1);
+    b4.x.x = b3.x.x;
+    b2.o = uint16_t(uvec2(b2.p).x);
+    b2.p = b2.v[1].y;
+    uvec3 v3 = uvec3(b2.w[b1.j], b2.w[b1.j+1], b2.w[b1.j+2]);
+    uvec3 u3 = uvec3(b5.w[b1.j], b5.w[b1.j+1], b5.w[b1.j+2]);
+    b2.x[0] = b2.x[0];
+    b2.x[1] = b5.x[1];
+    b2.p.x = b1.a;
+    b2.o = b2.p.x;
+    b2.p = u16vec2(uvec2(1, 2));
+    b2.o = uint16_t(3u);
+}
+

Test/spv.16bitstorage.frag

+#version 450 core
+
+#extension GL_EXT_shader_16bit_storage : enable
+
+struct S
+{
+    float16_t  x;
+    f16vec2    y;
+    f16vec3    z;
+};
+
+layout(column_major, std140) uniform B1
+{
+    float16_t  a;
+    f16vec2    b;
+    f16vec3    c;
+    float16_t  d[2];
+    S          g;
+    S          h[2];
+    int        j;
+} b1;
+
+layout(row_major, std430) buffer B2
+{
+    float16_t  o;
+    f16vec2    p;
+    f16vec3    q;
+    float16_t  r[2];
+    S          u;
+    S          v[2];
+    f16vec2    x[100];
+    float16_t  w[];
+} b2;
+
+layout(row_major, std140) uniform B5
+{
+    float16_t  o;
+    f16vec2    p;
+    f16vec3    q;
+    float16_t  r[2];
+    S          u;
+    S          v[2];
+    f16vec2    x[100];
+    float16_t  w[100];
+} b5;
+
+struct S2 {
+    mat4x4 x;
+    float16_t y;
+    float z;
+};
+
+struct S3 {
+    S2 x;
+};
+
+layout(row_major, std430) buffer B3
+{
+    S2 x;
+} b3;
+
+layout(column_major, std430) buffer B4
+{
+    S2 x;
+    S3 y;
+} b4;
+
+void main()
+{
+    b2.o = b1.a;
+    b2.p = f16vec2(vec3(b2.q).xy);
+    b2.p = f16vec2(vec3(b5.q).xy);
+    b2.r[0] = b2.r[0];
+    b2.r[1] = b5.r[1];
+    b2.p = b2.p;
+    float x0 = float(b1.a);
+    vec4 x1 = vec4(b1.a, b2.p, 1.0);
+    b4.x.x = b3.x.x;
+    b2.o = float16_t(vec2(b2.p).x);
+    b2.p = b2.v[1].y;
+    vec3 v3 = vec3(b2.w[b1.j], b2.w[b1.j+1], b2.w[b1.j+2]);
+    vec3 u3 = vec3(b5.w[b1.j], b5.w[b1.j+1], b5.w[b1.j+2]);
+    b2.x[0] = b2.x[0];
+    b2.x[1] = b5.x[1];
+    b2.p.x = b1.a;
+    b2.o = b2.p.x;
+    b2.p = f16vec2(vec2(1.0, 2.0));
+    b2.o = float16_t(3.0);
+}
+

Test/spv.16bitstorage_Error-int.frag

+#version 450 core
+
+#extension GL_EXT_shader_16bit_storage : enable
+
+struct S
+{
+    int16_t  x;
+    i16vec2    y;
+    i16vec3    z;
+};
+
+layout(column_major, std140) uniform B1
+{
+    int16_t  a;
+    i16vec2    b;
+    i16vec3    c;
+    int16_t  d[2];
+    S          g;
+    S          h[2];
+    int        j;
+} b1;
+
+layout(row_major, std430) buffer B2
+{
+    int16_t  o;
+    i16vec2    p;
+    i16vec3    q;
+    int16_t  r[2];
+    S          u;
+    S          v[2];
+    int16_t  w[];
+} b2;
+
+struct S2 {
+    mat4x4 x;
+    int16_t y;
+    int z;
+};
+
+struct S3 {
+    S2 x;
+};
+
+layout(row_major, std430) buffer B3
+{
+    S2 x;
+} b3;
+
+layout(column_major, std430) buffer B4
+{
+    S2 x;
+} b4;
+
+void func3(S2 x) {
+}
+
+S2 func4() {
+    return b4.x;
+}
+
+int func(int16_t a) {
+    return 0;
+}
+
+struct S4 {
+    int x;
+    int16_t y;
+};
+
+int func2(int a) { return 0; }
+
+void main()
+{
+    b2.o = b2.q[1];
+    b2.p = b2.q.xy;
+    b2.o = max(b1.a, b1.a);
+    bvec2 bv = lessThan(b2.p, b2.p);
+    b2.o = b1.a + b1.a;
+    b2.o = -b1.a;
+    b2.o = b1.a + 1;
+    b2.p = b2.p.yx;
+    b4.x = b3.x;
+    int16_t f0;
+    S2 f1;
+    S3 f2;
+    if (b1.a == b1.a) {}
+    b2.r = b2.r;
+    b2.p = i16vec2(3, 4);
+    i16vec2[2](i16vec2(ivec2(1,2)), i16vec2(ivec2(3,4)));
+    // NOT ERRORING YET
+    b3.x;
+    S4(0, int16_t(0));
+    func2(b1.a);
+}
+
+
+layout(column_major, std140) uniform B6
+{
+    i16mat2x3  e;
+} b6;
+

Test/spv.16bitstorage_Error-uint.frag

+#version 450 core
+
+#extension GL_EXT_shader_16bit_storage : enable
+
+struct S
+{
+    uint16_t  x;
+    u16vec2    y;
+    u16vec3    z;
+};
+
+layout(column_major, std140) uniform B1
+{
+    uint16_t  a;
+    u16vec2    b;
+    u16vec3    c;
+    uint16_t  d[2];
+    S          g;
+    S          h[2];
+    uint        j;
+} b1;
+
+layout(row_major, std430) buffer B2
+{
+    uint16_t  o;
+    u16vec2    p;
+    u16vec3    q;
+    uint16_t  r[2];
+    S          u;
+    S          v[2];
+    uint16_t  w[];
+} b2;
+
+struct S2 {
+    mat4x4 x;
+    uint16_t y;
+    uint z;
+};
+
+struct S3 {
+    S2 x;
+};
+
+layout(row_major, std430) buffer B3
+{
+    S2 x;
+} b3;
+
+layout(column_major, std430) buffer B4
+{
+    S2 x;
+} b4;
+
+void func3(S2 x) {
+}
+
+S2 func4() {
+    return b4.x;
+}
+
+uint func(uint16_t a) {
+    return 0;
+}
+
+struct S4 {
+    uint x;
+    uint16_t y;
+};
+
+uint func2(uint a) { return 0; }
+
+void main()
+{
+    b2.o = b2.q[1];
+    b2.p = b2.q.xy;
+    b2.o = max(b1.a, b1.a);
+    bvec2 bv = lessThan(b2.p, b2.p);
+    b2.o = b1.a + b1.a;
+    b2.o = -b1.a;
+    b2.o = b1.a + 1;
+    b2.p = b2.p.yx;
+    b4.x = b3.x;
+    uint16_t f0;
+    S2 f1;
+    S3 f2;
+    if (b1.a == b1.a) {}
+    b2.r = b2.r;
+    b2.p = u16vec2(3, 4);
+    u16vec2[2](u16vec2(uvec2(1,2)), u16vec2(uvec2(3,4)));
+    // NOT ERRORING YET
+    b3.x;
+    S4(0u, uint16_t(0u));
+    func2(b1.a);
+}
+
+
+layout(column_major, std140) uniform B6
+{
+    u16mat2x3  e;
+} b6;
+

Test/spv.16bitstorage_Error.frag

+#version 450 core
+
+#extension GL_EXT_shader_16bit_storage : enable
+
+struct S
+{
+    float16_t  x;
+    f16vec2    y;
+    f16vec3    z;
+};
+
+layout(column_major, std140) uniform B1
+{
+    float16_t  a;
+    f16vec2    b;
+    f16vec3    c;
+    float16_t  d[2];
+    S          g;
+    S          h[2];
+    int        j;
+} b1;
+
+layout(row_major, std430) buffer B2
+{
+    float16_t  o;
+    f16vec2    p;
+    f16vec3    q;
+    float16_t  r[2];
+    S          u;
+    S          v[2];
+    float16_t  w[];
+} b2;
+
+struct S2 {
+    mat4x4 x;
+    float16_t y;
+    float z;
+};
+
+struct S3 {
+    S2 x;
+};
+
+layout(row_major, std430) buffer B3
+{
+    S2 x;
+} b3;
+
+layout(column_major, std430) buffer B4
+{
+    S2 x;
+} b4;
+
+void func3(S2 x) {
+}
+
+S2 func4() {
+    return b4.x;
+}
+
+float func(float16_t a) {
+    return 0.0;
+}
+
+struct S4 {
+    float x;
+    float16_t y;
+};
+
+float func2(float a) { return 0.0; }
+
+void main()
+{
+    b2.o = b2.q[1];
+    b2.p = b2.q.xy;
+    b2.o = max(b1.a, b1.a);
+    bvec2 bv = lessThan(b2.p, b2.p);
+    b2.o = b1.a + b1.a;
+    b2.o = -b1.a;
+    b2.o = b1.a + 1.0;
+    b2.p = b2.p.yx;
+    b4.x = b3.x;
+    float16_t f0;
+    S2 f1;
+    S3 f2;
+    if (b1.a == b1.a) {}
+    b2.r = b2.r;
+    b2.o = 1.0HF;
+    b2.p = f16vec2(3.0, 4.0);
+    f16vec2[2](f16vec2(vec2(1.0,2.0)), f16vec2(vec2(3.0,4.0)));
+    // NOT ERRORING YET
+    b3.x;
+    S4(0.0, float16_t(0.0));
+    func2(b1.a);
+}
+
+
+layout(column_major, std140) uniform B6
+{
+    f16mat2x3  e;
+} b6;
+

Test/spv.8bitstorage-int.frag

+#version 450 core
+
+#extension GL_EXT_shader_8bit_storage : enable
+
+struct S
+{
+    int8_t  x;
+    i8vec2    y;
+    i8vec3    z;
+};
+
+layout(column_major, std140) uniform B1
+{
+    int8_t  a;
+    i8vec2    b;
+    i8vec3    c;
+    int8_t  d[2];
+    S          g;
+    S          h[2];
+    int        j;
+} b1;
+
+layout(row_major, std430) buffer B2
+{
+    int8_t  o;
+    i8vec2    p;
+    i8vec3    q;
+    int8_t  r[2];
+    S          u;
+    S          v[2];
+    i8vec2    x[100];
+    int8_t  w[];
+} b2;
+
+layout(row_major, std140) uniform B5
+{
+    int8_t  o;
+    i8vec2    p;
+    i8vec3    q;
+    int8_t  r[2];
+    S          u;
+    S          v[2];
+    i8vec2    x[100];
+    int8_t  w[100];
+} b5;
+
+struct S2 {
+    mat4x4 x;
+    int8_t y;
+    int z;
+};
+
+struct S3 {
+    S2 x;
+};
+
+layout(row_major, std430) buffer B3
+{
+    S2 x;
+} b3;
+
+layout(column_major, std430) buffer B4
+{
+    S2 x;
+    S3 y;
+} b4;
+
+void main()
+{
+    b2.o = b1.a;
+    b2.p = i8vec2(ivec3(b2.q).xy);
+    b2.p = i8vec2(ivec3(b5.q).xy);
+    b2.r[0] = b2.r[0];
+    b2.r[1] = b5.r[1];
+    b2.p = b2.p;
+    int x0 = int(b1.a);
+    ivec4 x1 = ivec4(b1.a, b2.p, 1);
+    b4.x.x = b3.x.x;
+    b2.o = int8_t(ivec2(b2.p).x);
+    b2.p = b2.v[1].y;
+    ivec3 v3 = ivec3(b2.w[b1.j], b2.w[b1.j+1], b2.w[b1.j+2]);
+    ivec3 u3 = ivec3(b5.w[b1.j], b5.w[b1.j+1], b5.w[b1.j+2]);
+    b2.x[0] = b2.x[0];
+    b2.x[1] = b5.x[1];
+    b2.p.x = b1.a;
+    b2.o = b2.p.x;
+    b2.p = i8vec2(ivec2(1, 2));
+    b2.o = int8_t(3);
+}
+

Test/spv.8bitstorage-uint.frag

+#version 450 core
+
+#extension GL_EXT_shader_8bit_storage : enable
+
+struct S
+{
+    uint8_t  x;
+    u8vec2    y;
+    u8vec3    z;
+};
+
+layout(column_major, std140) uniform B1
+{
+    uint8_t  a;
+    u8vec2    b;
+    u8vec3    c;
+    uint8_t  d[2];
+    S          g;
+    S          h[2];
+    uint        j;
+} b1;
+
+layout(row_major, std430) buffer B2
+{
+    uint8_t  o;
+    u8vec2    p;
+    u8vec3    q;
+    uint8_t  r[2];
+    S          u;
+    S          v[2];
+    u8vec2    x[100];
+    uint8_t  w[];
+} b2;
+
+layout(row_major, std140) uniform B5
+{
+    uint8_t  o;
+    u8vec2    p;
+    u8vec3    q;
+    uint8_t  r[2];
+    S          u;
+    S          v[2];
+    u8vec2    x[100];
+    uint8_t  w[100];
+} b5;
+
+struct S2 {
+    mat4x4 x;
+    uint8_t y;
+    uint z;
+};
+
+struct S3 {
+    S2 x;
+};
+
+layout(row_major, std430) buffer B3
+{
+    S2 x;
+} b3;
+
+layout(column_major, std430) buffer B4
+{
+    S2 x;
+    S3 y;
+} b4;
+
+void main()
+{
+    b2.o = b1.a;
+    b2.p = u8vec2(uvec3(b2.q).xy);
+    b2.p = u8vec2(uvec3(b5.q).xy);
+    b2.r[0] = b2.r[0];
+    b2.r[1] = b5.r[1];
+    b2.p = b2.p;
+    uint x0 = uint(b1.a);
+    uvec4 x1 = uvec4(b1.a, b2.p, 1);
+    b4.x.x = b3.x.x;
+    b2.o = uint8_t(uvec2(b2.p).x);
+    b2.p = b2.v[1].y;
+    uvec3 v3 = uvec3(b2.w[b1.j], b2.w[b1.j+1], b2.w[b1.j+2]);
+    uvec3 u3 = uvec3(b5.w[b1.j], b5.w[b1.j+1], b5.w[b1.j+2]);
+    b2.x[0] = b2.x[0];
+    b2.x[1] = b5.x[1];
+    b2.p.x = b1.a;
+    b2.o = b2.p.x;
+    b2.p = u8vec2(uvec2(1, 2));
+    b2.o = uint8_t(3u);
+}
+

Test/spv.8bitstorage_Error-int.frag

+#version 450 core
+
+#extension GL_EXT_shader_8bit_storage : enable
+
+struct S
+{
+    int8_t  x;
+    i8vec2    y;
+    i8vec3    z;
+};
+
+layout(column_major, std140) uniform B1
+{
+    int8_t  a;
+    i8vec2    b;
+    i8vec3    c;
+    int8_t  d[2];
+    S          g;
+    S          h[2];
+    int        j;
+} b1;
+
+layout(row_major, std430) buffer B2
+{
+    int8_t  o;
+    i8vec2    p;
+    i8vec3    q;
+    int8_t  r[2];
+    S          u;
+    S          v[2];
+    int8_t  w[];
+} b2;
+
+struct S2 {
+    mat4x4 x;
+    int8_t y;
+    int z;
+};
+
+struct S3 {
+    S2 x;
+};
+
+layout(row_major, std430) buffer B3
+{
+    S2 x;
+} b3;
+
+layout(column_major, std430) buffer B4
+{
+    S2 x;
+} b4;
+
+void func3(S2 x) {
+}
+
+S2 func4() {
+    return b4.x;
+}
+
+int func(int8_t a) {
+    return 0;
+}
+
+struct S4 {
+    int x;
+    int8_t y;
+};
+
+int func2(int a) { return 0; }
+
+void main()
+{
+    b2.o = b2.q[1];
+    b2.p = b2.q.xy;
+    b2.o = max(b1.a, b1.a);
+    bvec2 bv = lessThan(b2.p, b2.p);
+    b2.o = b1.a + b1.a;
+    b2.o = -b1.a;
+    b2.o = b1.a + 1;
+    b2.p = b2.p.yx;
+    b4.x = b3.x;
+    int8_t f0;
+    S2 f1;
+    S3 f2;
+    if (b1.a == b1.a) {}
+    b2.r = b2.r;
+    b2.p = i8vec2(3, 4);
+    i8vec2[2](i8vec2(ivec2(1,2)), i8vec2(ivec2(3,4)));
+    // NOT ERRORING YET
+    b3.x;
+    S4(0, int8_t(0));
+    func2(b1.a);
+}
+
+
+layout(column_major, std140) uniform B6
+{
+    i8mat2x3  e;
+} b6;
+

Test/spv.8bitstorage_Error-uint.frag

+#version 450 core
+
+#extension GL_EXT_shader_8bit_storage : enable
+
+struct S
+{
+    uint8_t  x;
+    u8vec2    y;
+    u8vec3    z;
+};
+
+layout(column_major, std140) uniform B1
+{
+    uint8_t  a;
+    u8vec2    b;
+    u8vec3    c;
+    uint8_t  d[2];
+    S          g;
+    S          h[2];
+    uint        j;
+} b1;
+
+layout(row_major, std430) buffer B2
+{
+    uint8_t  o;
+    u8vec2    p;
+    u8vec3    q;
+    uint8_t  r[2];
+    S          u;
+    S          v[2];
+    uint8_t  w[];
+} b2;
+
+struct S2 {
+    mat4x4 x;
+    uint8_t y;
+    uint z;
+};
+
+struct S3 {
+    S2 x;
+};
+
+layout(row_major, std430) buffer B3
+{
+    S2 x;
+} b3;
+
+layout(column_major, std430) buffer B4
+{
+    S2 x;
+} b4;
+
+void func3(S2 x) {
+}
+
+S2 func4() {
+    return b4.x;
+}
+
+uint func(uint8_t a) {
+    return 0;
+}
+
+struct S4 {
+    uint x;
+    uint8_t y;
+};
+
+uint func2(uint a) { return 0; }
+
+void main()
+{
+    b2.o = b2.q[1];
+    b2.p = b2.q.xy;
+    b2.o = max(b1.a, b1.a);
+    bvec2 bv = lessThan(b2.p, b2.p);
+    b2.o = b1.a + b1.a;
+    b2.o = -b1.a;
+    b2.o = b1.a + 1;
+    b2.p = b2.p.yx;
+    b4.x = b3.x;
+    uint8_t f0;
+    S2 f1;
+    S3 f2;
+    if (b1.a == b1.a) {}
+    b2.r = b2.r;
+    b2.p = u8vec2(3, 4);
+    u8vec2[2](u8vec2(uvec2(1,2)), u8vec2(uvec2(3,4)));
+    // NOT ERRORING YET
+    b3.x;
+    S4(0u, uint8_t(0u));
+    func2(b1.a);
+}
+
+
+layout(column_major, std140) uniform B6
+{
+    u8mat2x3  e;
+} b6;
+

glslang/Include/Types.h

@@ -1472,6 +1472,16 @@ public:
         return contains([](const TType* t) { return t->isArray() && t->arraySizes->isOuterSpecialization(); } );
     }
 
+    virtual bool contains16BitInt() const
+    {
+        return containsBasicType(EbtInt16) || containsBasicType(EbtUint16);
+    }
+
+    virtual bool contains8BitInt() const
+    {
+        return containsBasicType(EbtInt8) || containsBasicType(EbtUint8);
+    }
+
     // Array editing methods.  Array descriptors can be shared across
     // type instances.  This allows all uses of the same array
     // to be updated at once.  E.g., all nodes can be explicitly sized

glslang/Include/revision.h

 // This header is generated by the make-revision script.
 
-#define GLSLANG_PATCH_LEVEL 2796
+#define GLSLANG_PATCH_LEVEL 2797

glslang/MachineIndependent/Intermediate.cpp

@@ -881,6 +881,9 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
     // like vector and matrix sizes.
 
     TBasicType promoteTo;
+    // GL_EXT_shader_16bit_storage can't do OpConstantComposite with
+    // 16-bit types, so disable promotion for those types.
+    bool canPromoteConstant = true;
 
     switch (op) {
     //
@@ -897,18 +900,28 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
         break;
     case EOpConstructFloat16:
         promoteTo = EbtFloat16;
+        canPromoteConstant = extensionRequested(E_GL_KHX_shader_explicit_arithmetic_types) ||
+                             extensionRequested(E_GL_KHX_shader_explicit_arithmetic_types_float16);
         break;
     case EOpConstructInt8:
         promoteTo = EbtInt8;
+        canPromoteConstant = extensionRequested(E_GL_KHX_shader_explicit_arithmetic_types) ||
+                             extensionRequested(E_GL_KHX_shader_explicit_arithmetic_types_int8);
         break;
     case EOpConstructUint8:
         promoteTo = EbtUint8;
+        canPromoteConstant = extensionRequested(E_GL_KHX_shader_explicit_arithmetic_types) ||
+                             extensionRequested(E_GL_KHX_shader_explicit_arithmetic_types_int8);
         break;
     case EOpConstructInt16:
         promoteTo = EbtInt16;
+        canPromoteConstant = extensionRequested(E_GL_KHX_shader_explicit_arithmetic_types) ||
+                             extensionRequested(E_GL_KHX_shader_explicit_arithmetic_types_int16);
         break;
     case EOpConstructUint16:
         promoteTo = EbtUint16;
+        canPromoteConstant = extensionRequested(E_GL_KHX_shader_explicit_arithmetic_types) ||
+                             extensionRequested(E_GL_KHX_shader_explicit_arithmetic_types_int16);
         break;
     case EOpConstructInt:
         promoteTo = EbtInt;
@@ -999,7 +1012,7 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
             return nullptr;
     }
 
-    if (node->getAsConstantUnion())
+    if (canPromoteConstant && node->getAsConstantUnion())
         return promoteConstantUnion(promoteTo, node->getAsConstantUnion());
 
     //
@@ -1468,16 +1481,16 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat
             case EbtUint:
             case EbtInt64:
             case EbtUint64:
+            case EbtFloat:
+            case EbtDouble:
+                return true;
 #ifdef AMD_EXTENSIONS
             case EbtInt16:
             case EbtUint16:
+                return extensionRequested(E_GL_AMD_gpu_shader_int16);
+            case EbtFloat16:
+                return extensionRequested(E_GL_AMD_gpu_shader_half_float);
 #endif
-             case EbtFloat:
-             case EbtDouble:
-#ifdef AMD_EXTENSIONS
-             case EbtFloat16:
-#endif
-                return true;
             default:
                 return false;
            }
@@ -1485,17 +1498,21 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat
             switch (from) {
             case EbtInt:
             case EbtUint:
+            case EbtFloat:
+                 return true;
+            case EbtBool:
+                 return (source == EShSourceHlsl);
 #ifdef AMD_EXTENSIONS
             case EbtInt16:
             case EbtUint16:
+                return extensionRequested(E_GL_AMD_gpu_shader_int16);
 #endif
-            case EbtFloat:
-#ifdef AMD_EXTENSIONS
             case EbtFloat16:
+                return 
+#ifdef AMD_EXTENSIONS
+                    extensionRequested(E_GL_AMD_gpu_shader_half_float) ||
 #endif
-                 return true;
-            case EbtBool:
-                 return (source == EShSourceHlsl);
+                    (source == EShSourceHlsl);
             default:
                  return false;
             }
@@ -1504,25 +1521,27 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat
             case EbtInt:
                  return version >= 400 || (source == EShSourceHlsl);
             case EbtUint:
+                return true;
+            case EbtBool:
+                return (source == EShSourceHlsl);
 #ifdef AMD_EXTENSIONS
             case EbtInt16:
             case EbtUint16:
+                return extensionRequested(E_GL_AMD_gpu_shader_int16);
 #endif
-                return true;
-            case EbtBool:
-                return (source == EShSourceHlsl);
             default:
                 return false;
             }
         case EbtInt:
             switch (from) {
             case EbtInt:
-#ifdef AMD_EXTENSIONS
-            case EbtInt16:
-#endif
                 return true;
             case EbtBool:
                 return (source == EShSourceHlsl);
+#ifdef AMD_EXTENSIONS
+            case EbtInt16:
+                return extensionRequested(E_GL_AMD_gpu_shader_int16);
+#endif
             default:
                 return false;
             }
@@ -1532,11 +1551,12 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat
             case EbtUint:
             case EbtInt64:
             case EbtUint64:
+                return true;
 #ifdef AMD_EXTENSIONS
             case EbtInt16:
             case EbtUint16:
+                return extensionRequested(E_GL_AMD_gpu_shader_int16);
 #endif
-                return true;
             default:
                 return false;
             }
@@ -1544,32 +1564,36 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat
             switch (from) {
             case EbtInt:
             case EbtInt64:
+                return true;
 #ifdef AMD_EXTENSIONS
             case EbtInt16:
+                return extensionRequested(E_GL_AMD_gpu_shader_int16);
 #endif
-                return true;
             default:
                 return false;
             }
-#ifdef AMD_EXTENSIONS
         case EbtFloat16:
             switch (from) {
+#ifdef AMD_EXTENSIONS
             case EbtInt16:
             case EbtUint16:
+                return extensionRequested(E_GL_AMD_gpu_shader_int16);
             case EbtFloat16:
-                return true;
+                return extensionRequested(E_GL_AMD_gpu_shader_half_float);
+#endif
             default:
                 return false;
         }
         case EbtUint16:
             switch (from) {
+#ifdef AMD_EXTENSIONS
             case EbtInt16:
             case EbtUint16:
-                return true;
+                return extensionRequested(E_GL_AMD_gpu_shader_int16);
+#endif
             default:
                 return false;
         }
-#endif
         default:
             return false;
         }

glslang/MachineIndependent/ParseHelper.h

@@ -367,6 +367,7 @@ public:
     void nestedStructCheck(const TSourceLoc&);
     void arrayObjectCheck(const TSourceLoc&, const TType&, const char* op);
     void opaqueCheck(const TSourceLoc&, const TType&, const char* op);
+    void storage16BitAssignmentCheck(const TSourceLoc&, const TType&, const char* op);
     void specializationCheck(const TSourceLoc&, const TType&, const char* op);
     void structTypeCheck(const TSourceLoc&, TPublicType&);
     void inductiveLoopCheck(const TSourceLoc&, TIntermNode* init, TIntermLoop* loop);

glslang/MachineIndependent/Scan.cpp

@@ -1110,6 +1110,7 @@ int TScanContext::tokenizeIdentifier()
         afterType = true;
         if (parseContext.symbolTable.atBuiltInLevel() ||
             ((parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) ||
+              parseContext.extensionTurnedOn(E_GL_EXT_shader_8bit_storage) ||
               parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_int8)) &&
               parseContext.profile != EEsProfile && parseContext.version >= 450))
             return keyword;
@@ -1130,6 +1131,7 @@ int TScanContext::tokenizeIdentifier()
 #ifdef AMD_EXTENSIONS
               parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_int16) ||
 #endif
+              parseContext.extensionTurnedOn(E_GL_EXT_shader_16bit_storage) ||
               parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) ||
               parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_int16))))
             return keyword;
@@ -1201,6 +1203,20 @@ int TScanContext::tokenizeIdentifier()
     case F16VEC2:
     case F16VEC3:
     case F16VEC4:
+        afterType = true;
+        if (parseContext.symbolTable.atBuiltInLevel() ||
+            (parseContext.profile != EEsProfile && parseContext.version >= 450 &&
+             (
+#ifdef AMD_EXTENSIONS
+              parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_half_float) ||
+#endif
+              parseContext.extensionTurnedOn(E_GL_EXT_shader_16bit_storage) ||
+              parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) ||
+              parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_float16))))
+            return keyword;
+
+        return identifierOrType();
+
     case F16MAT2:
     case F16MAT3:
     case F16MAT4:

glslang/MachineIndependent/Versions.h

@@ -152,6 +152,10 @@ const char* const E_GL_KHR_shader_subgroup_quad             = "GL_KHR_shader_sub
 const char* const E_GL_EXT_shader_non_constant_global_initializers = "GL_EXT_shader_non_constant_global_initializers";
 const char* const E_GL_EXT_shader_image_load_formatted = "GL_EXT_shader_image_load_formatted";
 
+const char* const E_GL_EXT_shader_16bit_storage             = "GL_EXT_shader_16bit_storage";
+const char* const E_GL_EXT_shader_8bit_storage              = "GL_EXT_shader_8bit_storage";
+
+
 // EXT extensions
 const char* const E_GL_EXT_device_group                     = "GL_EXT_device_group";
 const char* const E_GL_EXT_multiview                        = "GL_EXT_multiview";

glslang/MachineIndependent/glslang.y

@@ -699,6 +699,7 @@ assignment_expression
     | unary_expression assignment_operator assignment_expression {
         parseContext.arrayObjectCheck($2.loc, $1->getType(), "array assignment");
         parseContext.opaqueCheck($2.loc, $1->getType(), "=");
+        parseContext.storage16BitAssignmentCheck($2.loc, $1->getType(), "=");
         parseContext.specializationCheck($2.loc, $1->getType(), "=");
         parseContext.lValueErrorCheck($2.loc, "assign", $1);
         parseContext.rValueErrorCheck($2.loc, "assign", $3);
@@ -1419,7 +1420,7 @@ type_specifier_nonarray
         $$.basicType = EbtDouble;
     }
     | FLOAT16_T {
-        parseContext.float16Check($1.loc, "float16_t", parseContext.symbolTable.atBuiltInLevel());
+        parseContext.float16ScalarVectorCheck($1.loc, "float16_t", parseContext.symbolTable.atBuiltInLevel());
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtFloat16;
     }
@@ -1443,22 +1444,22 @@ type_specifier_nonarray
         $$.basicType = EbtUint;
     }
     | INT8_T {
-        parseContext.explicitInt8Check($1.loc, "8-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
+        parseContext.int8ScalarVectorCheck($1.loc, "8-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtInt8;
     }
     | UINT8_T {
-        parseContext.explicitInt8Check($1.loc, "8-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
+        parseContext.int8ScalarVectorCheck($1.loc, "8-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtUint8;
     }
     | INT16_T {
-        parseContext.explicitInt16Check($1.loc, "16-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
+        parseContext.int16ScalarVectorCheck($1.loc, "16-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtInt16;
     }
     | UINT16_T {
-        parseContext.explicitInt16Check($1.loc, "16-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
+        parseContext.int16ScalarVectorCheck($1.loc, "16-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtUint16;
     }
@@ -1520,19 +1521,19 @@ type_specifier_nonarray
         $$.setVector(4);
     }
     | F16VEC2 {
-        parseContext.float16Check($1.loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
+        parseContext.float16ScalarVectorCheck($1.loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtFloat16;
         $$.setVector(2);
     }
     | F16VEC3 {
-        parseContext.float16Check($1.loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
+        parseContext.float16ScalarVectorCheck($1.loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtFloat16;
         $$.setVector(3);
     }
     | F16VEC4 {
-        parseContext.float16Check($1.loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
+        parseContext.float16ScalarVectorCheck($1.loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtFloat16;
         $$.setVector(4);
@@ -1604,40 +1605,40 @@ type_specifier_nonarray
         $$.setVector(4);
     }
     | I8VEC2 {
-       parseContext.explicitInt8Check($1.loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
-       $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
-       $$.basicType = EbtInt8;
-       $$.setVector(2);
+        parseContext.int8ScalarVectorCheck($1.loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtInt8;
+        $$.setVector(2);
     }
     | I8VEC3 {
-       parseContext.explicitInt8Check($1.loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
-       $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
-       $$.basicType = EbtInt8;
-       $$.setVector(3);
+        parseContext.int8ScalarVectorCheck($1.loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtInt8;
+        $$.setVector(3);
     }
     | I8VEC4 {
-       parseContext.explicitInt8Check($1.loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
-       $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
-       $$.basicType = EbtInt8;
-       $$.setVector(4);
+        parseContext.int8ScalarVectorCheck($1.loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtInt8;
+        $$.setVector(4);
     }
     | I16VEC2 {
-       parseContext.explicitInt16Check($1.loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
-       $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
-       $$.basicType = EbtInt16;
-       $$.setVector(2);
+        parseContext.int16ScalarVectorCheck($1.loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtInt16;
+        $$.setVector(2);
     }
     | I16VEC3 {
-       parseContext.explicitInt16Check($1.loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
-       $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
-       $$.basicType = EbtInt16;
-       $$.setVector(3);
+        parseContext.int16ScalarVectorCheck($1.loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtInt16;
+        $$.setVector(3);
     }
     | I16VEC4 {
-       parseContext.explicitInt16Check($1.loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
-       $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
-       $$.basicType = EbtInt16;
-       $$.setVector(4);
+        parseContext.int16ScalarVectorCheck($1.loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtInt16;
+        $$.setVector(4);
     }
     | I32VEC2 {
         parseContext.explicitInt32Check($1.loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
@@ -1694,37 +1695,37 @@ type_specifier_nonarray
         $$.setVector(4);
     }
     | U8VEC2 {
-        parseContext.explicitInt8Check($1.loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
+        parseContext.int8ScalarVectorCheck($1.loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtUint8;
         $$.setVector(2);
     }
     | U8VEC3 {
-        parseContext.explicitInt8Check($1.loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
+        parseContext.int8ScalarVectorCheck($1.loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
-        $$.basicType = EbtInt8;
+        $$.basicType = EbtUint8;
         $$.setVector(3);
     }
     | U8VEC4 {
-        parseContext.explicitInt8Check($1.loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
+        parseContext.int8ScalarVectorCheck($1.loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtUint8;
         $$.setVector(4);
     }
     | U16VEC2 {
-        parseContext.explicitInt16Check($1.loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
+        parseContext.int16ScalarVectorCheck($1.loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtUint16;
         $$.setVector(2);
     }
     | U16VEC3 {
-        parseContext.explicitInt16Check($1.loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
+        parseContext.int16ScalarVectorCheck($1.loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtUint16;
         $$.setVector(3);
     }
     | U16VEC4 {
-        parseContext.explicitInt16Check($1.loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
+        parseContext.int16ScalarVectorCheck($1.loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtUint16;
         $$.setVector(4);

glslang/MachineIndependent/parseVersions.h

@@ -79,6 +79,15 @@ public:
     virtual void fullIntegerCheck(const TSourceLoc&, const char* op);
     virtual void doubleCheck(const TSourceLoc&, const char* op);
     virtual void float16Check(const TSourceLoc&, const char* op, bool builtIn = false);
+    virtual void float16ScalarVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false);
+    virtual bool float16Arithmetic();
+    virtual void requireFloat16Arithmetic(const TSourceLoc& loc, const char* featureDesc);
+    virtual void int16ScalarVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false);
+    virtual bool int16Arithmetic();
+    virtual void requireInt16Arithmetic(const TSourceLoc& loc, const char* featureDesc);
+    virtual void int8ScalarVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false);
+    virtual bool int8Arithmetic();
+    virtual void requireInt8Arithmetic(const TSourceLoc& loc, const char* featureDesc);
 #ifdef AMD_EXTENSIONS
     virtual void float16OpaqueCheck(const TSourceLoc&, const char* op, bool builtIn = false);
 #endif

glslang/Public/ShaderLang.h

@@ -70,7 +70,7 @@
 // This should always increase, as some paths to do not consume
 // a more major number.
 // It should increment by one when new functionality is added.
-#define GLSLANG_MINOR_VERSION 7
+#define GLSLANG_MINOR_VERSION 8
 
 //
 // Call before doing any other compiler/linker operations.

gtests/Spv.FromFile.cpp

@@ -215,6 +215,12 @@ INSTANTIATE_TEST_CASE_P(
         "spv.140.frag",
         "spv.150.geom",
         "spv.150.vert",
+        "spv.16bitstorage.frag",
+        "spv.16bitstorage_Error.frag",
+        "spv.16bitstorage-int.frag",
+        "spv.16bitstorage_Error-int.frag",
+        "spv.16bitstorage-uint.frag",
+        "spv.16bitstorage_Error-uint.frag",
         "spv.300BuiltIns.vert",
         "spv.300layout.frag",
         "spv.300layout.vert",
@@ -231,6 +237,10 @@ INSTANTIATE_TEST_CASE_P(
         "spv.450.tesc",
         "spv.450.geom",
         "spv.450.noRedecl.tesc",
+        "spv.8bitstorage-int.frag",
+        "spv.8bitstorage_Error-int.frag",
+        "spv.8bitstorage-uint.frag",
+        "spv.8bitstorage_Error-uint.frag",
         "spv.accessChain.frag",
         "spv.aggOps.frag",
         "spv.always-discard.frag",

known_good_khr.json

@@ -12,7 +12,7 @@
       "site" : "gitlab",
       "subrepo" : "spirv/SPIRV-Headers",
       "subdir" : "External/spirv-tools/external/spirv-headers",
-      "commit" : "4082a777bd5df31ed45acf40e64263094e85ed2e"
+      "commit" : "gitlab-prelim-rc4"
     }
   ]
 }