Prelude is associated with SourceLanguage (shader-slang#1398)

* Associate a downstream compiler for prelude lookup even if output is source.

* Remove LanguageStyle and just use SourceLanguage instread.

* Added set/getPrelude.
Made prelude work on source language.

* Fix typo in method name replacement.
get/SetPrelude get/setLanguagePrelude

* Fix issue because of method name change.

* Remove getPreludeDownstreamCompilerForTarget

Author: jsmall-zzz

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

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-compiler.cpp

@@ -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;

source/slang/slang-compiler.h

@@ -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)];
     };