Updated glslang.

3rdparty/glslang/SPIRV/GlslangToSpv.cpp

@@ -4731,7 +4731,7 @@ spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermO
             // imageAtomicStore has a void return type so base the pointer type on
             // the type of the value operand.
             if (node->getOp() == glslang::EOpImageAtomicStore) {
-                resultTypeId = builder.makePointer(spv::StorageClassImage, builder.getTypeId(operands[2].word));                
+                resultTypeId = builder.makePointer(spv::StorageClassImage, builder.getTypeId(*opIt));
             } else {
                 resultTypeId = builder.makePointer(spv::StorageClassImage, resultType());
             }

3rdparty/glslang/glslang/CInterface/glslang_c_interface.cpp

@@ -42,18 +42,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "glslang/Include/ResourceLimits.h"
 #include "glslang/MachineIndependent/Versions.h"
 
-static_assert(GLSLANG_STAGE_COUNT == EShLangCount, "");
-static_assert(GLSLANG_STAGE_MASK_COUNT == EShLanguageMaskCount, "");
-static_assert(GLSLANG_SOURCE_COUNT == glslang::EShSourceCount, "");
-static_assert(GLSLANG_CLIENT_COUNT == glslang::EShClientCount, "");
-static_assert(GLSLANG_TARGET_COUNT == glslang::EShTargetCount, "");
-static_assert(GLSLANG_TARGET_CLIENT_VERSION_COUNT == glslang::EShTargetClientVersionCount, "");
-static_assert(GLSLANG_TARGET_LANGUAGE_VERSION_COUNT == glslang::EShTargetLanguageVersionCount, "");
-static_assert(GLSLANG_OPT_LEVEL_COUNT == EshOptLevelCount, "");
-static_assert(GLSLANG_TEX_SAMP_TRANS_COUNT == EShTexSampTransCount, "");
-static_assert(GLSLANG_MSG_COUNT == EShMsgCount, "");
-static_assert(GLSLANG_REFLECTION_COUNT == EShReflectionCount, "");
-static_assert(GLSLANG_PROFILE_COUNT == EProfileCount, "");
+static_assert(int(GLSLANG_STAGE_COUNT) == EShLangCount, "");
+static_assert(int(GLSLANG_STAGE_MASK_COUNT) == EShLanguageMaskCount, "");
+static_assert(int(GLSLANG_SOURCE_COUNT) == glslang::EShSourceCount, "");
+static_assert(int(GLSLANG_CLIENT_COUNT) == glslang::EShClientCount, "");
+static_assert(int(GLSLANG_TARGET_COUNT) == glslang::EShTargetCount, "");
+static_assert(int(GLSLANG_TARGET_CLIENT_VERSION_COUNT) == glslang::EShTargetClientVersionCount, "");
+static_assert(int(GLSLANG_TARGET_LANGUAGE_VERSION_COUNT) == glslang::EShTargetLanguageVersionCount, "");
+static_assert(int(GLSLANG_OPT_LEVEL_COUNT) == EshOptLevelCount, "");
+static_assert(int(GLSLANG_TEX_SAMP_TRANS_COUNT) == EShTexSampTransCount, "");
+static_assert(int(GLSLANG_MSG_COUNT) == EShMsgCount, "");
+static_assert(int(GLSLANG_REFLECTION_COUNT) == EShReflectionCount, "");
+static_assert(int(GLSLANG_PROFILE_COUNT) == EProfileCount, "");
 
 typedef struct glslang_shader_s {
     glslang::TShader* shader;
@@ -314,6 +314,8 @@ static EProfile c_shader_profile(glslang_profile_t profile)
         return ECompatibilityProfile;
     case GLSLANG_ES_PROFILE:
         return EEsProfile;
+    case GLSLANG_PROFILE_COUNT: // Should not use this
+        break;
     }
 
     return EProfile();

3rdparty/glslang/glslang/CMakeLists.txt

@@ -6,9 +6,10 @@ else(WIN32)
     message("unknown platform")
 endif(WIN32)
 
-if(EMSCRIPTEN OR ENABLE_GLSLANG_WEB)
+if(EMSCRIPTEN OR ENABLE_GLSLANG_JS)
+    # May be enabled on non-Emscripten builds for binary-size testing.
     add_subdirectory(OSDependent/Web)
-endif(EMSCRIPTEN OR ENABLE_GLSLANG_WEB)
+endif(EMSCRIPTEN OR ENABLE_GLSLANG_JS)
 
 set(SOURCES
     MachineIndependent/glslang.m4
@@ -86,8 +87,8 @@ set_property(TARGET glslang PROPERTY FOLDER glslang)
 set_property(TARGET glslang PROPERTY POSITION_INDEPENDENT_CODE ON)
 target_link_libraries(glslang OGLCompiler OSDependent)
 target_include_directories(glslang PUBLIC 
-	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
-	$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
 
 if(WIN32 AND BUILD_SHARED_LIBS)
     set_target_properties(glslang PROPERTIES PREFIX "")
@@ -115,7 +116,7 @@ if(ENABLE_GLSLANG_INSTALL)
         install(TARGETS glslang EXPORT glslangTargets
                 ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
     endif()
-	install(EXPORT glslangTargets DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
+    install(EXPORT glslangTargets DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
 endif(ENABLE_GLSLANG_INSTALL)
 
 if(ENABLE_GLSLANG_INSTALL)

3rdparty/glslang/glslang/MachineIndependent/Constant.cpp

@@ -1012,6 +1012,7 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode)
     case EOpMin:
     case EOpMax:
     case EOpMix:
+    case EOpMod:
     case EOpClamp:
     case EOpLessThan:
     case EOpGreaterThan:
@@ -1074,6 +1075,15 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode)
             case EOpPow:
                 newConstArray[comp].setDConst(pow(childConstUnions[0][arg0comp].getDConst(), childConstUnions[1][arg1comp].getDConst()));
                 break;
+            case EOpMod:
+            {
+                double arg0 = childConstUnions[0][arg0comp].getDConst();
+                double arg1 = childConstUnions[1][arg1comp].getDConst();
+                assert(arg1 != 0.0);
+                double result = arg0 - arg1 * floor(arg0 / arg1);
+                newConstArray[comp].setDConst(result);
+                break;
+            }
             case EOpMin:
                 switch(children[0]->getAsTyped()->getBasicType()) {
                 case EbtFloat16:

3rdparty/glslang/glslang/MachineIndependent/Intermediate.cpp

@@ -3237,10 +3237,17 @@ bool TIntermediate::promoteUnary(TIntermUnary& node)
 
             return false;
         break;
-
     default:
-        if (operand->getBasicType() != EbtFloat)
+        // HLSL uses this path for initial function signature finding for built-ins
+        // taking a single argument, which generally don't participate in
+        // operator-based type promotion (type conversion will occur later).
+        // For now, scalar argument cases are relying on the setType() call below.
+        if (getSource() == EShSourceHlsl)
+            break;
 
+        // GLSL only allows integer arguments for the cases identified above in the
+        // case statements.
+        if (operand->getBasicType() != EbtFloat)
             return false;
     }
 

3rdparty/glslang/glslang/MachineIndependent/ParseHelper.cpp

@@ -1672,6 +1672,9 @@ void TParseContext::memorySemanticsCheck(const TSourceLoc& loc, const TFunction&
     unsigned int semantics = 0, storageClassSemantics = 0;
     unsigned int semantics2 = 0, storageClassSemantics2 = 0;
 
+    const TIntermTyped* arg0 = (*argp)[0]->getAsTyped();
+    const bool isMS = arg0->getBasicType() == EbtSampler && arg0->getType().getSampler().isMultiSample();
+
     // Grab the semantics and storage class semantics from the operands, based on opcode
     switch (callNode.getOp()) {
     case EOpAtomicAdd:
@@ -1704,18 +1707,18 @@ void TParseContext::memorySemanticsCheck(const TSourceLoc& loc, const TFunction&
     case EOpImageAtomicXor:
     case EOpImageAtomicExchange:
     case EOpImageAtomicStore:
-        storageClassSemantics = (*argp)[4]->getAsConstantUnion()->getConstArray()[0].getIConst();
-        semantics = (*argp)[5]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        storageClassSemantics = (*argp)[isMS ? 5 : 4]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        semantics = (*argp)[isMS ? 6 : 5]->getAsConstantUnion()->getConstArray()[0].getIConst();
         break;
     case EOpImageAtomicLoad:
-        storageClassSemantics = (*argp)[3]->getAsConstantUnion()->getConstArray()[0].getIConst();
-        semantics = (*argp)[4]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        storageClassSemantics = (*argp)[isMS ? 4 : 3]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        semantics = (*argp)[isMS ? 5 : 4]->getAsConstantUnion()->getConstArray()[0].getIConst();
         break;
     case EOpImageAtomicCompSwap:
-        storageClassSemantics = (*argp)[5]->getAsConstantUnion()->getConstArray()[0].getIConst();
-        semantics = (*argp)[6]->getAsConstantUnion()->getConstArray()[0].getIConst();
-        storageClassSemantics2 = (*argp)[7]->getAsConstantUnion()->getConstArray()[0].getIConst();
-        semantics2 = (*argp)[8]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        storageClassSemantics = (*argp)[isMS ? 6 : 5]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        semantics = (*argp)[isMS ? 7 : 6]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        storageClassSemantics2 = (*argp)[isMS ? 8 : 7]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        semantics2 = (*argp)[isMS ? 9 : 8]->getAsConstantUnion()->getConstArray()[0].getIConst();
         break;
 
     case EOpBarrier:

3rdparty/glslang/glslang/MachineIndependent/iomapper.cpp

@@ -579,7 +579,10 @@ TDefaultGlslIoResolver::TDefaultGlslIoResolver(const TIntermediate& intermediate
 
 int TDefaultGlslIoResolver::resolveInOutLocation(EShLanguage stage, TVarEntryInfo& ent) {
     const TType& type = ent.symbol->getType();
-    const TString& name = ent.symbol->getName();
+    const TString& name = IsAnonymous(ent.symbol->getName()) ?
+                            ent.symbol->getType().getTypeName()
+                            :
+                            ent.symbol->getName();
     if (currentStage != stage) {
         preStage = currentStage;
         currentStage = stage;
@@ -663,7 +666,10 @@ int TDefaultGlslIoResolver::resolveInOutLocation(EShLanguage stage, TVarEntryInf
 
 int TDefaultGlslIoResolver::resolveUniformLocation(EShLanguage /*stage*/, TVarEntryInfo& ent) {
     const TType& type = ent.symbol->getType();
-    const TString& name = ent.symbol->getName();
+    const TString& name = IsAnonymous(ent.symbol->getName()) ?
+                            ent.symbol->getType().getTypeName()
+                            :
+                            ent.symbol->getName();
     // kick out of not doing this
     if (! doAutoLocationMapping()) {
         return ent.newLocation = -1;
@@ -734,7 +740,10 @@ int TDefaultGlslIoResolver::resolveUniformLocation(EShLanguage /*stage*/, TVarEn
 
 int TDefaultGlslIoResolver::resolveBinding(EShLanguage /*stage*/, TVarEntryInfo& ent) {
     const TType& type = ent.symbol->getType();
-    const TString& name = ent.symbol->getName();
+    const TString& name = IsAnonymous(ent.symbol->getName()) ?
+                            ent.symbol->getType().getTypeName()
+                            :
+                            ent.symbol->getName();
     // On OpenGL arrays of opaque types take a seperate binding for each element
     int numBindings = intermediate.getSpv().openGl != 0 && type.isSizedArray() ? type.getCumulativeArraySize() : 1;
     TResourceType resource = getResourceType(type);
@@ -809,7 +818,10 @@ void TDefaultGlslIoResolver::endCollect(EShLanguage /*stage*/) {
 
 void TDefaultGlslIoResolver::reserverStorageSlot(TVarEntryInfo& ent, TInfoSink& infoSink) {
     const TType& type = ent.symbol->getType();
-    const TString& name = ent.symbol->getName();
+    const TString& name = IsAnonymous(ent.symbol->getName()) ?
+                            ent.symbol->getType().getTypeName()
+                            :
+                            ent.symbol->getName();
     TStorageQualifier storage = type.getQualifier().storage;
     EShLanguage stage(EShLangCount);
     switch (storage) {
@@ -869,7 +881,10 @@ void TDefaultGlslIoResolver::reserverStorageSlot(TVarEntryInfo& ent, TInfoSink&
 
 void TDefaultGlslIoResolver::reserverResourceSlot(TVarEntryInfo& ent, TInfoSink& infoSink) {
     const TType& type = ent.symbol->getType();
-    const TString& name = ent.symbol->getName();
+    const TString& name = IsAnonymous(ent.symbol->getName()) ?
+                            ent.symbol->getType().getTypeName()
+                            :
+                            ent.symbol->getName();
     int resource = getResourceType(type);
     if (type.getQualifier().hasBinding()) {
         TVarSlotMap& varSlotMap = resourceSlotMap[resource];

3rdparty/glslang/glslang/OSDependent/Web/CMakeLists.txt

@@ -1,24 +1,34 @@
-add_executable(glslang.js "glslang.js.cpp")
-glslang_set_link_args(glslang.js)
-target_link_libraries(glslang.js glslang SPIRV)
-if(EMSCRIPTEN)
-    set_target_properties(glslang.js PROPERTIES
-        OUTPUT_NAME "glslang"
-        SUFFIX ".js")
-    em_link_pre_js(glslang.js "${CMAKE_CURRENT_SOURCE_DIR}/glslang.pre.js")
+if(ENABLE_GLSLANG_JS)
+    add_executable(glslang.js "glslang.js.cpp")
+    glslang_set_link_args(glslang.js)
+    target_link_libraries(glslang.js glslang SPIRV)
 
-    target_link_options(glslang.js PRIVATE
-        "SHELL:--bind -s MODULARIZE=1")
-    if(ENABLE_EMSCRIPTEN_ENVIRONMENT_NODE)
-        target_link_options(glslang.js PRIVATE
-            "SHELL:-s ENVIRONMENT=node -s BINARYEN_ASYNC_COMPILATION=0")
-    else()
-        target_link_options(glslang.js PRIVATE
-            "SHELL:-s ENVIRONMENT=web,worker")
-    endif()
+    if(EMSCRIPTEN)
+        set_target_properties(glslang.js PROPERTIES
+            OUTPUT_NAME "glslang"
+            SUFFIX ".js")
+        em_link_pre_js(glslang.js "${CMAKE_CURRENT_SOURCE_DIR}/glslang.pre.js")
 
-    if(NOT ENABLE_EMSCRIPTEN_ENVIRONMENT_NODE)
-        add_custom_command(TARGET glslang.js POST_BUILD
-            COMMAND cat ${CMAKE_CURRENT_SOURCE_DIR}/glslang.after.js >> ${CMAKE_CURRENT_BINARY_DIR}/glslang.js)
-    endif()
-endif(EMSCRIPTEN)
+        target_link_options(glslang.js PRIVATE "SHELL: -Os")
+        target_link_options(glslang.js PRIVATE "SHELL: --llvm-lto 1")
+        target_link_options(glslang.js PRIVATE "SHELL: --closure 1")
+        target_link_options(glslang.js PRIVATE "SHELL: -s MODULARIZE=1")
+        target_link_options(glslang.js PRIVATE "SHELL: -s ALLOW_MEMORY_GROWTH=1")
+        target_link_options(glslang.js PRIVATE "SHELL: -s FILESYSTEM=0")
+
+        if(ENABLE_EMSCRIPTEN_SINGLE_FILE)
+            target_link_options(glslang.js "SHELL: -s SINGLE_FILE=1")
+        endif(ENABLE_EMSCRIPTEN_SINGLE_FILE)
+
+        if(ENABLE_EMSCRIPTEN_ENVIRONMENT_NODE)
+            target_link_options(glslang.js PRIVATE "SHELL: -s ENVIRONMENT=node -s BINARYEN_ASYNC_COMPILATION=0")
+        else()
+            target_link_options(glslang.js PRIVATE "SHELL: -s ENVIRONMENT=web,worker")
+        endif()
+
+        if(NOT ENABLE_EMSCRIPTEN_ENVIRONMENT_NODE)
+            add_custom_command(TARGET glslang.js POST_BUILD
+                COMMAND cat ${CMAKE_CURRENT_SOURCE_DIR}/glslang.after.js >> ${CMAKE_CURRENT_BINARY_DIR}/glslang.js)
+        endif()
+    endif(EMSCRIPTEN)
+endif(ENABLE_GLSLANG_JS)

3rdparty/glslang/glslang/OSDependent/Web/glslang.js.cpp

@@ -176,7 +176,12 @@ extern "C" {
  * If null, the compilation failed.
  */
 EMSCRIPTEN_KEEPALIVE
-void* convert_glsl_to_spirv(const char* glsl, int stage_int, bool gen_debug, uint32_t** spirv, size_t* spirv_len)
+void* convert_glsl_to_spirv(const char* glsl,
+                            int stage_int,
+                            bool gen_debug,
+                            glslang::EShTargetLanguageVersion spirv_version,
+                            uint32_t** spirv,
+                            size_t* spirv_len)
 {
     if (glsl == nullptr) {
         fprintf(stderr, "Input pointer null\n");
@@ -194,6 +199,18 @@ void* convert_glsl_to_spirv(const char* glsl, int stage_int, bool gen_debug, uin
         return nullptr;
     }
     EShLanguage stage = static_cast<EShLanguage>(stage_int);
+    switch (spirv_version) {
+        case glslang::EShTargetSpv_1_0:
+        case glslang::EShTargetSpv_1_1:
+        case glslang::EShTargetSpv_1_2:
+        case glslang::EShTargetSpv_1_3:
+        case glslang::EShTargetSpv_1_4:
+        case glslang::EShTargetSpv_1_5:
+            break;
+        default:
+            fprintf(stderr, "Invalid SPIR-V version number\n");
+            return nullptr;
+    }
 
     if (!initialized) {
         glslang::InitializeProcess();
@@ -203,8 +220,8 @@ void* convert_glsl_to_spirv(const char* glsl, int stage_int, bool gen_debug, uin
     glslang::TShader shader(stage);
     shader.setStrings(&glsl, 1);
     shader.setEnvInput(glslang::EShSourceGlsl, stage, glslang::EShClientVulkan, 100);
-    shader.setEnvClient(glslang::EShClientVulkan, glslang::EShTargetVulkan_1_1);
-    shader.setEnvTarget(glslang::EShTargetSpv, glslang::EShTargetSpv_1_3);
+    shader.setEnvClient(glslang::EShClientVulkan, glslang::EShTargetVulkan_1_0);
+    shader.setEnvTarget(glslang::EShTargetSpv, spirv_version);
     if (!shader.parse(&DefaultTBuiltInResource, 100, true, EShMsgDefault)) {
         fprintf(stderr, "Parse failed\n");
         fprintf(stderr, "%s\n", shader.getInfoLog());
@@ -260,7 +277,7 @@ void main() { })";
     uint32_t* output;
     size_t output_len;
 
-    void* id = convert_glsl_to_spirv(input, 4, false, &output, &output_len);
+    void* id = convert_glsl_to_spirv(input, 4, false, glslang::EShTargetSpv_1_0, &output, &output_len);
     assert(output != nullptr);
     assert(output_len != 0);
     destroy_output_buffer(id);

3rdparty/glslang/glslang/OSDependent/Web/glslang.pre.js

@@ -1,23 +1,34 @@
-Module['compileGLSLZeroCopy'] = function(glsl, shader_stage, gen_debug) {
+Module['compileGLSLZeroCopy'] = function(glsl, shader_stage, gen_debug, spirv_version) {
     gen_debug = !!gen_debug;
 
-    var shader_stage_int;
-    if (shader_stage === 'vertex') {
-        shader_stage_int = 0;
-    } else if (shader_stage === 'fragment') {
-        shader_stage_int = 4;
-    } else if (shader_stage === 'compute') {
-        shader_stage_int = 5;
-    } else {
-        throw new Error("shader_stage must be 'vertex', 'fragment', or 'compute'");
+    var shader_stage_int; // EShLanguage
+    switch (shader_stage) {
+        case 'vertex':   shader_stage_int = 0; break;
+        case 'fragment': shader_stage_int = 4; break;
+        case 'compute':  shader_stage_int = 5; break;
+        default:
+            throw new Error("shader_stage must be 'vertex', 'fragment', or 'compute'.");
+    }
+
+    spirv_version = spirv_version || '1.0';
+    var spirv_version_int; // EShTargetLanguageVersion
+    switch (spirv_version) {
+        case '1.0': spirv_version_int = (1 << 16) | (0 << 8); break;
+        case '1.1': spirv_version_int = (1 << 16) | (1 << 8); break;
+        case '1.2': spirv_version_int = (1 << 16) | (2 << 8); break;
+        case '1.3': spirv_version_int = (1 << 16) | (3 << 8); break;
+        case '1.4': spirv_version_int = (1 << 16) | (4 << 8); break;
+        case '1.5': spirv_version_int = (1 << 16) | (5 << 8); break;
+        default:
+            throw new Error("spirv_version must be '1.0' ~ '1.5'.");
     }
 
     var p_output = Module['_malloc'](4);
     var p_output_len = Module['_malloc'](4);
     var id = ccall('convert_glsl_to_spirv',
         'number',
-        ['string', 'number', 'boolean', 'number', 'number'],
-        [glsl, shader_stage_int, gen_debug, p_output, p_output_len]);
+        ['string', 'number', 'boolean', 'number', 'number', 'number'],
+        [glsl, shader_stage_int, gen_debug, spirv_version_int, p_output, p_output_len]);
     var output = getValue(p_output, 'i32');
     var output_len = getValue(p_output_len, 'i32');
     Module['_free'](p_output);
@@ -37,8 +48,8 @@ Module['compileGLSLZeroCopy'] = function(glsl, shader_stage, gen_debug) {
     return ret;
 };
 
-Module['compileGLSL'] = function(glsl, shader_stage, gen_debug) {
-    var compiled = Module['compileGLSLZeroCopy'](glsl, shader_stage, gen_debug);
+Module['compileGLSL'] = function(glsl, shader_stage, gen_debug, spirv_version) {
+    var compiled = Module['compileGLSLZeroCopy'](glsl, shader_stage, gen_debug, spirv_version);
     var ret = compiled['data'].slice()
     compiled['free']();
     return ret;

3rdparty/glslang/hlsl/hlslParseHelper.cpp

@@ -7572,7 +7572,7 @@ const TFunction* HlslParseContext::findFunction(const TSourceLoc& loc, TFunction
 
         if (args->getAsAggregate()) {
             // Handle aggregates: put all args into the new function call
-            for (int arg=0; arg<int(args->getAsAggregate()->getSequence().size()); ++arg) {
+            for (int arg = 0; arg < int(args->getAsAggregate()->getSequence().size()); ++arg) {
                 // TODO: But for constness, we could avoid the new & shallowCopy, and use the pointer directly.
                 TParameter param = { 0, new TType, nullptr };
                 param.type->shallowCopy(args->getAsAggregate()->getSequence()[arg]->getAsTyped()->getType());