Merge branch 'master' into feature/prelude-fix

Author: csyonghe

examples/cpu-hello-world/main.cpp

@@ -61,8 +61,8 @@ static SlangResult _innerMain(int argc, char** argv)
     // directory called 'slang-cpp-prelude.h'.
     // 
     // We need to tell slang either the contents of the prelude, or suitable include/s
-    // that will work. The actual API call to set the prelude is `setDownstreamCompilerPrelude`
-    // and this just sets for a specific backend a bit of text placed before generated code.
+    // that will work. The actual API call to set the prelude is `setPrelude`
+    // and this just sets for a specific language a bit of text placed before generated code.
     //
     // Most downstream C++ compilers work on files. In that case slang may generate temporary
     // files that contain the generated code. Typically the generated files  will not be in the
@@ -184,7 +184,7 @@ static SlangResult _innerMain(int argc, char** argv)
     // We don't have any entry point parameters so that's passed as NULL
     // We need to cast our definition of the uniform state to the undefined CPPPrelude::UniformState as
     // that type is just a name to indicate what kind of thing needs to be passed in.
-    func(&varyingInput, NULL, (CPPPrelude::UniformState*)&uniformState);
+    func(&varyingInput, NULL, &uniformState);
 
     // bufferContents holds the output
 

prelude/slang-cpp-prelude.h

@@ -49,6 +49,4 @@
 #   define SLANG_UNROLL
 #endif
 
-#endif
-
-struct Context;
+#endif

prelude/slang-cpp-types.h

@@ -822,14 +822,11 @@ struct ComputeVaryingInput
     uint3 endGroupID;       ///< Non inclusive end groupID
 };
 
-/* Type that defines the uniform entry point params. The actual content of this type is dependent on the entry point parameters, and can be
-found via reflection or defined such that it matches the shader appropriately.
-*/
-struct UniformEntryPointParams;
-struct UniformState;
+// The uniformEntryPointParams and uniformState must be set to structures that match layout that the kernel expects.
+// This can be determined via reflection for example.
 
-typedef void(*ComputeThreadFunc)(ComputeThreadVaryingInput* varyingInput, UniformEntryPointParams* uniformEntryPointParams, UniformState* uniformState);
-typedef void(*ComputeFunc)(ComputeVaryingInput* varyingInput, UniformEntryPointParams* uniformEntryPointParams, UniformState* uniformState);
+typedef void(*ComputeThreadFunc)(ComputeThreadVaryingInput* varyingInput, void* uniformEntryPointParams, void* uniformState);
+typedef void(*ComputeFunc)(ComputeVaryingInput* varyingInput, void* uniformEntryPointParams, void* uniformState);
 
 #ifdef SLANG_PRELUDE_NAMESPACE
 }

slang.h

@@ -2862,7 +2862,9 @@ namespace slang
             SlangPassThrough passThrough,
             char const* path) = 0;
 
-            /** Set the 'prelude' for generated code for a 'downstream compiler'.
+            /** DEPRECIATED: Use setLanguagePrelude
+
+            Set the 'prelude' for generated code for a 'downstream compiler'.
             @param passThrough The downstream compiler for generated code that will have the prelude applied to it. 
             @param preludeText The text added pre-pended verbatim before the generated source
 
@@ -2872,7 +2874,9 @@ namespace slang
             SlangPassThrough passThrough,
             const char* preludeText) = 0;
 
-            /** Get the 'prelude' for generated code for a 'downstream compiler'.
+            /** DEPRECIATED: Use getLanguagePrelude
+
+            Get the 'prelude' for generated code for a 'downstream compiler'.
             @param passThrough The downstream compiler for generated code that will have the prelude applied to it. 
             @param outPrelude  On exit holds a blob that holds the string of the prelude.
             */
@@ -2909,6 +2913,25 @@ namespace slang
             @return The downstream compiler for that source language */
         virtual SlangPassThrough SLANG_MCALL getDefaultDownstreamCompiler(
             SlangSourceLanguage sourceLanguage) = 0;
+
+            /* Set the 'prelude' placed before generated code for a specific language type.
+            
+            @param sourceLanguage The language the prelude should be inserted on.
+            @param preludeText The text added pre-pended verbatim before the generated source
+
+            Note! That for pass-through usage, prelude is not pre-pended, preludes are for code generation only. 
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL setLanguagePrelude(
+            SlangSourceLanguage sourceLanguage,
+            const char* preludeText) = 0;
+
+            /** Get the 'prelude' associated with a specific source language. 
+            @param sourceLanguage The language the prelude should be inserted on.
+            @param outPrelude  On exit holds a blob that holds the string of the prelude.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL getLanguagePrelude(
+            SlangSourceLanguage sourceLanguage,
+            ISlangBlob** outPrelude) = 0;
     };
 
     #define SLANG_UUID_IGlobalSession { 0xc140b5fd, 0xc78, 0x452e, { 0xba, 0x7c, 0x1a, 0x1e, 0x70, 0xc7, 0xf7, 0x1c } };

source/core/slang-test-tool-util.cpp

@@ -59,36 +59,19 @@ static SlangResult _addCPPPrelude(const String& parentPath, slang::IGlobalSessio
 {
     String includePath;
     SLANG_RETURN_ON_FAIL(_calcIncludePath(parentPath, "../../../prelude/slang-cpp-prelude.h", includePath));
-
     StringBuilder prelude;
     prelude << "#include \"" << includePath << "\"\n\n";
-    const SlangPassThrough downstreamCompilers[] = {
-        SLANG_PASS_THROUGH_CLANG,                   ///< Clang C/C++ compiler 
-        SLANG_PASS_THROUGH_VISUAL_STUDIO,           ///< Visual studio C/C++ compiler
-        SLANG_PASS_THROUGH_GCC,                     ///< GCC C/C++ compiler
-        SLANG_PASS_THROUGH_GENERIC_C_CPP,
-    };
-    for (auto downstreamCompiler : downstreamCompilers)
-    {
-        session->setDownstreamCompilerPrelude(downstreamCompiler, prelude.getBuffer());
-    }
+    session->setLanguagePrelude(SLANG_SOURCE_LANGUAGE_CPP, prelude.getBuffer());
     return SLANG_OK;
 }
 
 static SlangResult _addCUDAPrelude(const String& parentPath, slang::IGlobalSession* session)
 {
     String includePath;
     SLANG_RETURN_ON_FAIL(_calcIncludePath(parentPath, "../../../prelude/slang-cuda-prelude.h", includePath));
-
     StringBuilder prelude;
     prelude << "#include \"" << includePath << "\"\n\n";
-    const SlangPassThrough downstreamCompilers[] = {
-        SLANG_PASS_THROUGH_NVRTC,                   ///< nvrtc CUDA compiler
-    };
-    for (auto downstreamCompiler : downstreamCompilers)
-    {
-        session->setDownstreamCompilerPrelude(downstreamCompiler, prelude.getBuffer());
-    }
+    session->setLanguagePrelude(SLANG_SOURCE_LANGUAGE_CUDA, prelude.getBuffer());
     return SLANG_OK;
 }
 

source/slang/slang-check-shader.cpp

@@ -544,7 +544,7 @@ namespace Slang
         auto entryPointProfile = entryPointReq->getProfile();
         if( auto entryPointAttribute = entryPointFuncDecl->findModifier<EntryPointAttribute>() )
         {
-            auto entryPointStage = entryPointProfile.GetStage();
+            auto entryPointStage = entryPointProfile.getStage();
             if( entryPointStage == Stage::Unknown )
             {
                 entryPointProfile.setStage(entryPointAttribute->stage);

source/slang/slang-compiler.cpp

@@ -320,7 +320,7 @@ namespace Slang
 
     //
 
-    Profile Profile::LookUp(char const* name)
+    Profile Profile::lookUp(char const* name)
     {
         #define PROFILE(TAG, NAME, STAGE, VERSION)	if(strcmp(name, #NAME) == 0) return Profile::TAG;
         #define PROFILE_ALIAS(TAG, DEF, NAME)		if(strcmp(name, #NAME) == 0) return Profile::TAG;
@@ -408,36 +408,58 @@ namespace Slang
         return session->getOrLoadDownstreamCompiler(passThrough, nullptr) ? SLANG_OK: SLANG_E_NOT_FOUND;
     }
 
-    PassThroughMode getPreludeDownstreamCompilerForTarget(Session* session, CodeGenTarget target)
+    SourceLanguage getDefaultSourceLanguageForDownstreamCompiler(PassThroughMode compiler)
     {
-        switch (target)
+        switch (compiler)
         {
-            case CodeGenTarget::None:
+            case PassThroughMode::None:
             {
-                return PassThroughMode::None;
+                return SourceLanguage::Unknown;
             }
-            case CodeGenTarget::GLSL:
+            case PassThroughMode::Fxc:   
+            case PassThroughMode::Dxc:
             {
-                // For the prelude we'll use Glslang
-                return PassThroughMode::Glslang;
+                return SourceLanguage::HLSL;
             }
-            case CodeGenTarget::HLSL:
+            case PassThroughMode::Glslang:
             {
-                // Use the default compiler for the source language if set, 
-                DownstreamCompiler* downstreamCompiler = session->getDefaultDownstreamCompiler(SourceLanguage::HLSL);
-                if (downstreamCompiler)
-                {
-                    return PassThroughMode(downstreamCompiler->getDesc().type);
-                }
-                else
-                {
-                    // This is ambiguous, because we could use dxc or fxc. For now we'll go with Dxc. 
-                    return PassThroughMode::Dxc;
-                }
+                return SourceLanguage::GLSL;
+            }
+            case PassThroughMode::Clang:
+            case PassThroughMode::VisualStudio:
+            case PassThroughMode::Gcc:
+            case PassThroughMode::GenericCCpp:
+            {
+                // These could ingest C, but we only have this function to work out a
+                // 'default' language to ingest.
+                return SourceLanguage::CPP;
             }
+            case PassThroughMode::NVRTC:
+            {
+                return SourceLanguage::CUDA;
+            }
+            default: break;
+        }
+        SLANG_ASSERT(!"Unknown compiler");
+        return SourceLanguage::Unknown;
+    }
+
+    PassThroughMode getDownstreamCompilerRequiredForTarget(CodeGenTarget target)
+    {
+        switch (target)
+        {
+            // Don't *require* a downstream compiler for source output
+            case CodeGenTarget::GLSL:
+            case CodeGenTarget::HLSL:
             case CodeGenTarget::CUDASource:
+            case CodeGenTarget::CPPSource:
+            case CodeGenTarget::CSource:
             {
-                return PassThroughMode::NVRTC;
+                return PassThroughMode::None;
+            }
+            case CodeGenTarget::None:
+            {
+                return PassThroughMode::None;
             }
             case CodeGenTarget::SPIRVAssembly:
             case CodeGenTarget::SPIRV:
@@ -459,12 +481,6 @@ namespace Slang
             {
                 return PassThroughMode::Glslang;
             }
-            case CodeGenTarget::CPPSource:
-            case CodeGenTarget::CSource:
-            {
-                // We'll just use the generic C/C++ compiler
-                return PassThroughMode::GenericCCpp;
-            }
             case CodeGenTarget::HostCallable:
             case CodeGenTarget::SharedLibrary:
             case CodeGenTarget::Executable:
@@ -484,28 +500,9 @@ namespace Slang
         return PassThroughMode::None;
     }
 
-    PassThroughMode getDownstreamCompilerRequiredForTarget(Session* session, CodeGenTarget target)
-    {
-        switch (target)
-        {
-            // Don't *require* a downstream compiler for source output
-            case CodeGenTarget::GLSL:
-            case CodeGenTarget::HLSL:
-            case CodeGenTarget::CUDASource:
-            case CodeGenTarget::CPPSource:
-            case CodeGenTarget::CSource:
-            {
-                return PassThroughMode::None;
-            }
-            default: break;
-        }
-
-        return getPreludeDownstreamCompilerForTarget(session, target);
-    }
-
     SlangResult checkCompileTargetSupport(Session* session, CodeGenTarget target)
     {
-        const PassThroughMode mode = getDownstreamCompilerRequiredForTarget(session, target);
+        const PassThroughMode mode = getDownstreamCompilerRequiredForTarget(target);
         return (mode != PassThroughMode::None) ?
             checkExternalCompilerSupport(session, mode) :
             SLANG_OK;
@@ -634,7 +631,7 @@ namespace Slang
         }
 
         char const* stagePrefix = nullptr;
-        switch( profile.GetStage() )
+        switch( profile.getStage() )
         {
             // Note: All of the raytracing-related stages require
             // compiling for a `lib_*` profile, even when only a
@@ -669,7 +666,7 @@ namespace Slang
         }
 
         char const* versionSuffix = nullptr;
-        switch(profile.GetVersion())
+        switch(profile.getVersion())
         {
     #define CASE(TAG, SUFFIX) case ProfileVersion::TAG: versionSuffix = #SUFFIX; break
         CASE(DX_4_0,             _4_0);

source/slang/slang-compiler.h

@@ -180,7 +180,7 @@ namespace Slang
         Name* getName() { return m_name; }
 
             /// Get the stage that the entry point is to be compiled for
-        Stage getStage() { return m_profile.GetStage(); }
+        Stage getStage() { return m_profile.getStage(); }
 
             /// Get the profile that the entry point is to be compiled for
         Profile getProfile() { return m_profile; }
@@ -725,7 +725,7 @@ namespace Slang
         Profile getProfile() { return m_profile; }
 
             /// Get the stage that the entry point is for.
-        Stage getStage() { return m_profile.GetStage(); }
+        Stage getStage() { return m_profile.getStage(); }
 
             /// Get the module that contains the entry point.
         Module* getModule();
@@ -1191,9 +1191,9 @@ namespace Slang
     };
 
         /// Given a target returns the required downstream compiler
-    PassThroughMode getDownstreamCompilerRequiredForTarget(Session* session, CodeGenTarget target);
+    PassThroughMode getDownstreamCompilerRequiredForTarget(CodeGenTarget target);
         /// Given a target returns a downstream compiler the prelude should be taken from.
-    PassThroughMode getPreludeDownstreamCompilerForTarget(Session* session, CodeGenTarget target);
+    SourceLanguage getDefaultSourceLanguageForDownstreamCompiler(PassThroughMode compiler);
 
     struct TypeCheckingCache;
 
@@ -2033,7 +2033,10 @@ namespace Slang
 
         SLANG_NO_THROW SlangPassThrough SLANG_MCALL getDefaultDownstreamCompiler(SlangSourceLanguage sourceLanguage) override;
 
-            /// Get the default cpp compiler for a language
+        SLANG_NO_THROW void SLANG_MCALL setLanguagePrelude(SlangSourceLanguage inSourceLanguage, char const* prelude) override;
+        SLANG_NO_THROW void SLANG_MCALL getLanguagePrelude(SlangSourceLanguage inSourceLanguage, ISlangBlob** outPrelude) override;
+
+            /// Get the default compiler for a language
         DownstreamCompiler* getDefaultDownstreamCompiler(SourceLanguage sourceLanguage);
 
         enum class SharedLibraryFuncType
@@ -2103,8 +2106,8 @@ namespace Slang
 
         SlangFuncPtr getSharedLibraryFunc(SharedLibraryFuncType type, DiagnosticSink* sink);
 
-            /// Get the downstream compiler prelude
-        const String& getDownstreamCompilerPrelude(PassThroughMode mode) { return m_downstreamCompilerPreludes[int(mode)]; }
+            /// Get the prelude associated with the language
+        const String& getPreludeForLanguage(SourceLanguage language) { return m_languagePreludes[int(language)]; }
 
         void init();
 
@@ -2128,12 +2131,11 @@ namespace Slang
 
         SlangResult _loadRequest(EndToEndCompileRequest* request, const void* data, size_t size);
 
-        
             /// Linkage used for all built-in (stdlib) code.
         RefPtr<Linkage> m_builtinLinkage;
 
-        String m_downstreamCompilerPaths[int(PassThroughMode::CountOf)];              ///< Paths for each pass through
-        String m_downstreamCompilerPreludes[int(PassThroughMode::CountOf)];             ///< Prelude for each type of target
+        String m_downstreamCompilerPaths[int(PassThroughMode::CountOf)];         ///< Paths for each pass through
+        String m_languagePreludes[int(SourceLanguage::CountOf)];                  ///< Prelude for each source language
         PassThroughMode m_defaultDownstreamCompilers[int(SourceLanguage::CountOf)];
     };
 

source/slang/slang-dxc-support.cpp

@@ -185,7 +185,7 @@ namespace Slang
         // TODO: Ideally the dxc back-end should be passed some information
         // on the "capabilities" that were used and/or requested in the code.
         //
-        if( profile.GetVersion() >= ProfileVersion::DX_6_2 )
+        if( profile.getVersion() >= ProfileVersion::DX_6_2 )
         {
             args[argCount++] = L"-enable-16bit-types";
         }
@@ -195,7 +195,7 @@ namespace Slang
         ComPtr<IDxcOperationResult> dxcResult;
         SLANG_RETURN_ON_FAIL(dxcCompiler->Compile(dxcSourceBlob,
             sourcePath.toWString().begin(),
-            profile.GetStage() == Stage::Unknown ? L"" : wideEntryPointName.begin(),
+            profile.getStage() == Stage::Unknown ? L"" : wideEntryPointName.begin(),
             wideProfileName.begin(),
             args,
             argCount,