Merge branch 'master' into hlsl/hlsl-set-supported-versio-to-2021

Author: zlatinski

CMakeLists.txt

@@ -199,7 +199,19 @@ advanced_option(
 )
 advanced_option(
     SLANG_OVERRIDE_GLSLANG_PATH
-    "Build using user defined path for glslang, this also requires "
+    "Build using user defined path for glslang"
+    OFF
+)
+
+advanced_option(
+    SLANG_EXCLUDE_DAWN
+    "Optionally exclude webgpu_dawn from the build"
+    OFF
+)
+
+advanced_option(
+    SLANG_EXCLUDE_TINT
+    "Optionally exclude slang-tint from the build"
     OFF
 )
 
@@ -292,24 +304,28 @@ if(SLANG_SLANG_LLVM_FLAVOR MATCHES FETCH_BINARY)
     )
 endif()
 
-set(webgpu_dawn_release_tag "webgpu_dawn-0")
-if(
-    CMAKE_SYSTEM_NAME MATCHES "Windows"
-    AND CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|amd64|AMD64"
-)
-    set(SLANG_WEBGPU_DAWN_BINARY_URL
-        "https://github.com/shader-slang/dawn/releases/download/${webgpu_dawn_release_tag}/webgpu_dawn-windows-x64.zip"
+if(NOT SLANG_EXCLUDE_DAWN)
+    set(webgpu_dawn_release_tag "webgpu_dawn-0")
+    if(
+        CMAKE_SYSTEM_NAME MATCHES "Windows"
+        AND CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|amd64|AMD64"
     )
+        set(SLANG_WEBGPU_DAWN_BINARY_URL
+            "https://github.com/shader-slang/dawn/releases/download/${webgpu_dawn_release_tag}/webgpu_dawn-windows-x64.zip"
+        )
+    endif()
 endif()
 
-set(slang_tint_release_tag "slang-tint-0")
-if(
-    CMAKE_SYSTEM_NAME MATCHES "Windows"
-    AND CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|amd64|AMD64"
-)
-    set(SLANG_SLANG_TINT_BINARY_URL
-        "https://github.com/shader-slang/dawn/releases/download/${slang_tint_release_tag}/slang-tint-windows-x64.zip"
+if(NOT SLANG_EXCLUDE_TINT)
+    set(slang_tint_release_tag "slang-tint-0")
+    if(
+        CMAKE_SYSTEM_NAME MATCHES "Windows"
+        AND CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|amd64|AMD64"
     )
+        set(SLANG_SLANG_TINT_BINARY_URL
+            "https://github.com/shader-slang/dawn/releases/download/${slang_tint_release_tag}/slang-tint-windows-x64.zip"
+        )
+    endif()
 endif()
 
 #

source/compiler-core/slang-downstream-compiler.h

@@ -340,6 +340,9 @@ class IDownstreamCompiler : public ICastable
     /// Disassemble and print to stdout
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL
     disassemble(const uint32_t* contents, int contentsSize) = 0;
+    /// Disassemble and return the result as a string
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
+    disassembleWithResult(const uint32_t* contents, int contentsSize, String& outString) = 0;
 
     /// True if underlying compiler uses file system to communicate source
     virtual SLANG_NO_THROW bool SLANG_MCALL isFileBased() = 0;
@@ -398,6 +401,17 @@ class DownstreamCompilerBase : public ComBaseObject, public IDownstreamCompiler
         return SLANG_FAIL;
     }
 
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL disassembleWithResult(
+        const uint32_t* contents,
+        int contentsSize,
+        String& outString) SLANG_OVERRIDE
+    {
+        SLANG_UNUSED(contents);
+        SLANG_UNUSED(contentsSize);
+        SLANG_UNUSED(outString);
+        return SLANG_FAIL;
+    }
+
     DownstreamCompilerBase(const Desc& desc)
         : m_desc(desc)
     {

source/compiler-core/slang-glslang-compiler.cpp

@@ -49,6 +49,10 @@ class GlslangDownstreamCompiler : public DownstreamCompilerBase
     validate(const uint32_t* contents, int contentsSize) SLANG_OVERRIDE;
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL
     disassemble(const uint32_t* contents, int contentsSize) SLANG_OVERRIDE;
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL disassembleWithResult(
+        const uint32_t* contents,
+        int contentsSize,
+        String& outString) SLANG_OVERRIDE;
     int link(
         const uint32_t** modules,
         const uint32_t* moduleSizes,
@@ -71,6 +75,7 @@ class GlslangDownstreamCompiler : public DownstreamCompilerBase
     glslang_CompileFunc_1_2 m_compile_1_2 = nullptr;
     glslang_ValidateSPIRVFunc m_validate = nullptr;
     glslang_DisassembleSPIRVFunc m_disassemble = nullptr;
+    glslang_DisassembleSPIRVWithResultFunc m_disassembleWithResult = nullptr;
     glslang_LinkSPIRVFunc m_link = nullptr;
 
     ComPtr<ISlangSharedLibrary> m_sharedLibrary;
@@ -86,6 +91,8 @@ SlangResult GlslangDownstreamCompiler::init(ISlangSharedLibrary* library)
     m_validate = (glslang_ValidateSPIRVFunc)library->findFuncByName("glslang_validateSPIRV");
     m_disassemble =
         (glslang_DisassembleSPIRVFunc)library->findFuncByName("glslang_disassembleSPIRV");
+    m_disassembleWithResult = (glslang_DisassembleSPIRVWithResultFunc)library->findFuncByName(
+        "glslang_disassembleSPIRVWithResult");
     m_link = (glslang_LinkSPIRVFunc)library->findFuncByName("glslang_linkSPIRV");
 
     if (m_compile_1_0 == nullptr && m_compile_1_1 == nullptr && m_compile_1_2 == nullptr)
@@ -316,6 +323,28 @@ SlangResult GlslangDownstreamCompiler::validate(const uint32_t* contents, int co
     return SLANG_FAIL;
 }
 
+SlangResult GlslangDownstreamCompiler::disassembleWithResult(
+    const uint32_t* contents,
+    int contentsSize,
+    String& outString)
+{
+    if (m_disassembleWithResult == nullptr)
+    {
+        return SLANG_FAIL;
+    }
+
+    char* resultString = nullptr;
+    if (m_disassembleWithResult(contents, contentsSize, &resultString))
+    {
+        if (resultString)
+        {
+            outString = String(resultString);
+            return SLANG_OK;
+        }
+    }
+    return SLANG_FAIL;
+}
+
 SlangResult GlslangDownstreamCompiler::disassemble(const uint32_t* contents, int contentsSize)
 {
     if (m_disassemble == nullptr)

source/slang-glslang/slang-glslang.cpp

@@ -184,36 +184,64 @@ extern "C"
     return tools.Validate(contents, contentsSize, options);
 }
 
-// Disassemble the given SPIRV-ASM instructions.
+// Disassemble the given SPIRV-ASM instructions and return the result as a string.
 extern "C"
 #ifdef _MSC_VER
     _declspec(dllexport)
 #else
-    __attribute__((__visibility__("default")))
+__attribute__((__visibility__("default")))
 #endif
-        bool glslang_disassembleSPIRV(const uint32_t* contents, int contentsSize)
+        bool glslang_disassembleSPIRVWithResult(
+            const uint32_t* contents,
+            int contentsSize,
+            char** outString)
 {
     static const auto kDefaultEnvironment = SPV_ENV_UNIVERSAL_1_5;
+    spv_text text;
 
     uint32_t options = SPV_BINARY_TO_TEXT_OPTION_NONE;
     options |= SPV_BINARY_TO_TEXT_OPTION_COMMENT;
-    options |= SPV_BINARY_TO_TEXT_OPTION_PRINT;
-    options |= SPV_BINARY_TO_TEXT_OPTION_COLOR;
     options |= SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES;
+    options |= SPV_BINARY_TO_TEXT_OPTION_INDENT;
 
     spv_diagnostic diagnostic = nullptr;
     spv_context context = spvContextCreate(kDefaultEnvironment);
     spv_result_t error =
-        spvBinaryToText(context, contents, contentsSize, options, nullptr, &diagnostic);
+        spvBinaryToText(context, contents, contentsSize, options, &text, &diagnostic);
     spvContextDestroy(context);
     if (error)
     {
         spvDiagnosticPrint(diagnostic);
         spvDiagnosticDestroy(diagnostic);
         return false;
     }
+    else
+    {
+        if (outString)
+        {
+            // Allocate memory for the output string and copy the result
+            size_t len = text->length + 1; // +1 for null terminator
+            *outString = new char[len];
+            memcpy(*outString, text->str, text->length);
+            (*outString)[text->length] = '\0'; // Ensure null termination
+        }
 
-    return true;
+        spvTextDestroy(text);
+        return true;
+    }
+}
+
+
+// Disassemble the given SPIRV-ASM instructions.
+extern "C"
+#ifdef _MSC_VER
+    _declspec(dllexport)
+#else
+__attribute__((__visibility__("default")))
+#endif
+        bool glslang_disassembleSPIRV(const uint32_t* contents, int contentsSize)
+{
+    return glslang_disassembleSPIRVWithResult(contents, contentsSize, nullptr);
 }
 
 // Apply the SPIRV-Tools optimizer to generated SPIR-V based on the desired optimization level
@@ -997,6 +1025,8 @@ extern "C"
         spvtools::Context context(SPV_ENV_UNIVERSAL_1_5);
         spvtools::LinkerOptions options = {};
 
+        options.SetUseHighestVersion(true);
+
         spvtools::MessageConsumer consumer = [](spv_message_level_t level,
                                                 const char* source,
                                                 const spv_position_t& position,

source/slang-glslang/slang-glslang.h

@@ -166,5 +166,9 @@ typedef int (*glslang_CompileFunc_1_1)(glslang_CompileRequest_1_1* request);
 typedef int (*glslang_CompileFunc_1_2)(glslang_CompileRequest_1_2* request);
 typedef bool (*glslang_ValidateSPIRVFunc)(const uint32_t* contents, int contentsSize);
 typedef bool (*glslang_DisassembleSPIRVFunc)(const uint32_t* contents, int contentsSize);
+typedef bool (*glslang_DisassembleSPIRVWithResultFunc)(
+    const uint32_t* contents,
+    int contentsSize,
+    char** outString);
 typedef bool (*glslang_LinkSPIRVFunc)(glslang_LinkRequest* request);
 #endif

source/slang-llvm/slang-llvm.cpp

@@ -1,4 +1,3 @@
-
 #include "clang/Basic/Stack.h"
 #include "clang/Basic/TargetOptions.h"
 #include "clang/Basic/Version.h"
@@ -147,6 +146,16 @@ class LLVMDownstreamCompiler : public ComBaseObject, public IDownstreamCompiler
         SLANG_UNUSED(contentsSize);
         return SLANG_FAIL;
     }
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL disassembleWithResult(
+        const uint32_t* contents,
+        int contentsSize,
+        String& outString) SLANG_OVERRIDE
+    {
+        SLANG_UNUSED(contents);
+        SLANG_UNUSED(contentsSize);
+        SLANG_UNUSED(outString);
+        return SLANG_FAIL;
+    }
 
     LLVMDownstreamCompiler()
         : m_desc(

source/slang/slang-check-conversion.cpp

@@ -396,14 +396,35 @@ bool SemanticsVisitor::createInvokeExprForSynthesizedCtor(
 {
     StructDecl* structDecl = isDeclRefTypeOf<StructDecl>(toType).getDecl();
 
-    if (!structDecl || !_getSynthesizedConstructor(
-                           structDecl,
-                           ConstructorDecl::ConstructorFlavor::SynthesizedDefault))
+    if (!structDecl)
         return false;
 
     HashSet<Type*> isVisit;
-    bool isCStyle = isCStyleType(toType, isVisit);
+    bool isCStyle = false;
+    if (!_getSynthesizedConstructor(
+            structDecl,
+            ConstructorDecl::ConstructorFlavor::SynthesizedDefault))
+    {
+        // When a struct has no constructor and it's not a C-style type, the initializer list is
+        // invalid.
+        isCStyle = isCStyleType(toType, isVisit);
+
+        // WAR: We currently still has to allow legacy initializer list for array type until we have
+        // more proper solution for array initialization, so if the right hand side is an array
+        // type, we will not report error and fall-back to legacy initializer list logic.
+        bool isArrayType = as<ArrayExpressionType>(toType) != nullptr;
+        if (!isCStyle && !isArrayType)
+        {
+            getSink()->diagnose(
+                fromInitializerListExpr->loc,
+                Diagnostics::cannotUseInitializerListForType,
+                toType);
+        }
+
+        return false;
+    }
 
+    isCStyle = isCStyleType(toType, isVisit);
     // TODO: This is just a special case for a backwards-compatibility feature
     // for HLSL, this flag will imply that the initializer list is synthesized
     // for a type cast from a literal zero to a 'struct'. In this case, we will fall

source/slang/slang-check-decl.cpp

@@ -12412,7 +12412,7 @@ bool SemanticsDeclAttributesVisitor::_synthesizeCtorSignature(StructDecl* struct
     // any constructors. see:
     // https://github.com/shader-slang/slang/blob/master/docs/proposals/004-initialization.md#inheritance-initialization
     if (_hasExplicitConstructor(structDecl, true))
-        return false;
+        return true;
 
     // synthesize the signature first.
     // The constructor's visibility level is the same as the struct itself.

source/slang/slang-check-shader.cpp

@@ -537,9 +537,17 @@ void validateEntryPoint(EntryPoint* entryPoint, DiagnosticSink* sink)
         }
         else
         {
-            // Only attempt to error if a user adds to slangc either `-profile` or `-capability`
-            if ((target->getOptionSet().hasOption(CompilerOptionName::Capability) ||
-                 target->getOptionSet().hasOption(CompilerOptionName::Profile)) &&
+            auto& targetOptionSet = target->getOptionSet();
+            bool specificProfileRequested =
+                targetOptionSet.hasOption(CompilerOptionName::Profile) &&
+                (targetOptionSet.getIntOption(CompilerOptionName::Profile) !=
+                 SLANG_PROFILE_UNKNOWN);
+            bool specificCapabilityRequested =
+                targetOptionSet.hasOption(CompilerOptionName::Capability) &&
+                (targetOptionSet.getIntOption(CompilerOptionName::Capability) !=
+                 SLANG_CAPABILITY_UNKNOWN);
+            // Only attempt to error if a specific profile or capability is requested
+            if ((specificCapabilityRequested || specificProfileRequested) &&
                 targetCaps.atLeastOneSetImpliedInOther(
                     entryPointFuncDecl->inferredCapabilityRequirements) ==
                     CapabilitySet::ImpliesReturnFlags::NotImplied)

source/slang/slang-compiler-tu.cpp

@@ -95,6 +95,18 @@ Module::precompileForTarget(SlangCompileTarget target, slang::IBlob** outDiagnos
 {
     CodeGenTarget targetEnum = CodeGenTarget(target);
 
+    // Don't precompile twice for the same target
+    for (auto globalInst : getIRModule()->getModuleInst()->getChildren())
+    {
+        if (auto inst = as<IREmbeddedDownstreamIR>(globalInst))
+        {
+            if (inst->getTarget() == targetEnum)
+            {
+                return SLANG_OK;
+            }
+        }
+    }
+
     auto module = getIRModule();
     auto linkage = getLinkage();
     auto builder = IRBuilder(module);

source/slang/slang-emit-spirv.cpp

@@ -91,7 +91,7 @@ enum class SpvLogicalSectionID
 };
 
 // The registered id for the Slang compiler.
-static const uint32_t kSPIRVSlangCompilerId = 40;
+static const uint32_t kSPIRVSlangCompilerId = 40 << 16;
 
 // While the SPIR-V module is nominally (according to the spec) just
 // a flat sequence of instructions, in practice some of the instructions