From 5a86cd4880f8f086631352cb5d67d60c58c087f4 Mon Sep 17 00:00:00 2001 From: jsmall-nvidia Date: Thu, 18 Jun 2020 11:38:30 -0400 Subject: Improvements around C++ code generation (#1396) * * Remove UniformState and UniformEntryPointParams types * Put all output C++ source in an anonymous namespace * If SLANG_PRELUDE_NAMESPACE is set, make what it defines available in generated file. * Fix signature issue in performance-profile.slang * Context -> KernelContext to avoid ambiguity. * Fix issues around dynamic dispatch and anonymous namespace. * Fix typo. --- examples/cpu-hello-world/main.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'examples/cpu-hello-world/main.cpp') diff --git a/examples/cpu-hello-world/main.cpp b/examples/cpu-hello-world/main.cpp index 6e06f64bc..4302e6069 100644 --- a/examples/cpu-hello-world/main.cpp +++ b/examples/cpu-hello-world/main.cpp @@ -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 -- cgit v1.2.3 From 5952e3b3d7f505a7e6d71ecd0793911224f5bac3 Mon Sep 17 00:00:00 2001 From: jsmall-nvidia Date: Thu, 18 Jun 2020 16:39:06 -0400 Subject: Prelude is associated with SourceLanguage (#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 --- examples/cpu-hello-world/main.cpp | 4 +- slang.h | 27 ++++++++++- source/core/slang-test-tool-util.cpp | 21 +-------- source/slang/slang-compiler.cpp | 89 +++++++++++++++++------------------- source/slang/slang-compiler.h | 18 ++++---- source/slang/slang-emit-c-like.cpp | 64 +++++++++++++------------- source/slang/slang-emit-c-like.h | 23 +++------- source/slang/slang-emit-glsl.cpp | 6 +-- source/slang/slang-emit-hlsl.cpp | 4 +- source/slang/slang-emit.cpp | 61 +++++------------------- source/slang/slang.cpp | 45 +++++++++++++++--- tools/render-test/slang-support.cpp | 2 +- 12 files changed, 176 insertions(+), 188 deletions(-) (limited to 'examples/cpu-hello-world/main.cpp') diff --git a/examples/cpu-hello-world/main.cpp b/examples/cpu-hello-world/main.cpp index 4302e6069..8f22aac6d 100644 --- a/examples/cpu-hello-world/main.cpp +++ b/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 diff --git a/slang.h b/slang.h index 9720b04cb..fd6655fea 100644 --- a/slang.h +++ b/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 } }; diff --git a/source/core/slang-test-tool-util.cpp b/source/core/slang-test-tool-util.cpp index 3b89321a1..f8e163758 100644 --- a/source/core/slang-test-tool-util.cpp +++ b/source/core/slang-test-tool-util.cpp @@ -59,19 +59,9 @@ 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; } @@ -79,16 +69,9 @@ static SlangResult _addCUDAPrelude(const String& parentPath, slang::IGlobalSessi { 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; } diff --git a/source/slang/slang-compiler.cpp b/source/slang/slang-compiler.cpp index b64169db4..fe0f7d69c 100644 --- a/source/slang/slang-compiler.cpp +++ b/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; diff --git a/source/slang/slang-compiler.h b/source/slang/slang-compiler.h index ba0c94e99..e4b537e19 100644 --- a/source/slang/slang-compiler.h +++ b/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 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)]; }; diff --git a/source/slang/slang-emit-c-like.cpp b/source/slang/slang-emit-c-like.cpp index eae3bdedc..6c004c84c 100644 --- a/source/slang/slang-emit-c-like.cpp +++ b/source/slang/slang-emit-c-like.cpp @@ -78,7 +78,7 @@ struct CLikeSourceEmitter::ComputeEmitActionsContext /* !!!!!!!!!!!!!!!!!!!!!!!!!!!! CLikeSourceEmitter !!!!!!!!!!!!!!!!!!!!!!!!!! */ -/* static */CLikeSourceEmitter::SourceStyle CLikeSourceEmitter::getSourceStyle(CodeGenTarget target) +/* static */SourceLanguage CLikeSourceEmitter::getSourceLanguage(CodeGenTarget target) { switch (target) { @@ -86,17 +86,17 @@ struct CLikeSourceEmitter::ComputeEmitActionsContext case CodeGenTarget::Unknown: case CodeGenTarget::None: { - return SourceStyle::Unknown; + return SourceLanguage::Unknown; } case CodeGenTarget::GLSL: case CodeGenTarget::GLSL_Vulkan: case CodeGenTarget::GLSL_Vulkan_OneDesc: { - return SourceStyle::GLSL; + return SourceLanguage::GLSL; } case CodeGenTarget::HLSL: { - return SourceStyle::HLSL; + return SourceLanguage::HLSL; } case CodeGenTarget::PTX: case CodeGenTarget::SPIRV: @@ -106,19 +106,19 @@ struct CLikeSourceEmitter::ComputeEmitActionsContext case CodeGenTarget::DXIL: case CodeGenTarget::DXILAssembly: { - return SourceStyle::Unknown; + return SourceLanguage::Unknown; } case CodeGenTarget::CSource: { - return SourceStyle::C; + return SourceLanguage::C; } case CodeGenTarget::CPPSource: { - return SourceStyle::CPP; + return SourceLanguage::CPP; } case CodeGenTarget::CUDASource: { - return SourceStyle::CUDA; + return SourceLanguage::CUDA; } } } @@ -126,8 +126,8 @@ struct CLikeSourceEmitter::ComputeEmitActionsContext CLikeSourceEmitter::CLikeSourceEmitter(const Desc& desc) { m_writer = desc.sourceWriter; - m_sourceStyle = getSourceStyle(desc.target); - SLANG_ASSERT(m_sourceStyle != SourceStyle::Unknown); + m_sourceLanguage = getSourceLanguage(desc.target); + SLANG_ASSERT(m_sourceLanguage != SourceLanguage::Unknown); m_target = desc.target; @@ -389,17 +389,17 @@ void CLikeSourceEmitter::maybeCloseParens(bool needClose) bool CLikeSourceEmitter::isTargetIntrinsicModifierApplicable(const String& targetName) { - switch(getSourceStyle()) + switch(getSourceLanguage()) { default: SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled code generation target"); return false; - case SourceStyle::C: return targetName == "c"; - case SourceStyle::CPP: return targetName == "cpp"; - case SourceStyle::GLSL: return targetName == "glsl"; - case SourceStyle::HLSL: return targetName == "hlsl"; - case SourceStyle::CUDA: return targetName == "cuda"; + case SourceLanguage::C: return targetName == "c"; + case SourceLanguage::CPP: return targetName == "cpp"; + case SourceLanguage::GLSL: return targetName == "glsl"; + case SourceLanguage::HLSL: return targetName == "hlsl"; + case SourceLanguage::CUDA: return targetName == "cuda"; } } @@ -552,7 +552,7 @@ String CLikeSourceEmitter::scrubName(const String& name) // and write some legal characters to the output as we go. StringBuilder sb; - if(getSourceStyle() == SourceStyle::GLSL) + if(getSourceLanguage() == SourceLanguage::GLSL) { // GLSL reserves all names that start with `gl_`, // so if we are in danger of collision, then make @@ -667,7 +667,7 @@ String CLikeSourceEmitter::generateName(IRInst* inst) auto entryPointDecor = inst->findDecoration(); if (entryPointDecor) { - if (getSourceStyle() == SourceStyle::GLSL) + if (getSourceLanguage() == SourceLanguage::GLSL) { // GLSL will always need to use `main` as the // name for an entry-point function, but other @@ -1011,7 +1011,7 @@ bool CLikeSourceEmitter::shouldFoldInstIntoUseSites(IRInst* inst) // GLSL doesn't allow texture/resource types to // be used as first-class values, so we need // to fold them into their use sites in all cases - if (getSourceStyle() == SourceStyle::GLSL) + if (getSourceLanguage() == SourceLanguage::GLSL) { if(as(type)) { @@ -1219,12 +1219,12 @@ void CLikeSourceEmitter::emitInstResultDecl(IRInst* inst) { // "Ordinary" instructions at module scope are constants - switch (getSourceStyle()) + switch (getSourceLanguage()) { - case SourceStyle::CUDA: - case SourceStyle::HLSL: - case SourceStyle::C: - case SourceStyle::CPP: + case SourceLanguage::CUDA: + case SourceLanguage::HLSL: + case SourceLanguage::C: + case SourceLanguage::CPP: m_writer->emit("static "); break; @@ -1652,7 +1652,7 @@ void CLikeSourceEmitter::emitIntrinsicCallExprImpl( for(IRIntegerValue ii = elementCount; ii < 4; ++ii) { m_writer->emit(", "); - if(getSourceStyle() == SourceStyle::GLSL) + if(getSourceLanguage() == SourceLanguage::GLSL) { emitSimpleType(elementType); m_writer->emit("(0)"); @@ -1710,7 +1710,7 @@ void CLikeSourceEmitter::emitIntrinsicCallExprImpl( auto arg = args[argIndex].get(); if(arg->op == kIROp_ImageSubscript) { - if(getSourceStyle() == SourceStyle::GLSL) + if(getSourceLanguage() == SourceLanguage::GLSL) { // TODO: we don't handle the multisample // case correctly here, where the last @@ -2003,7 +2003,7 @@ void CLikeSourceEmitter::defaultEmitInstExpr(IRInst* inst, const EmitOpInfo& inO auto base = fieldExtract->getBase(); emitOperand(base, leftSide(outerPrec, prec)); m_writer->emit("."); - if(getSourceStyle() == SourceStyle::GLSL + if(getSourceLanguage() == SourceLanguage::GLSL && as(base->getDataType())) { m_writer->emit("_data."); @@ -2023,7 +2023,7 @@ void CLikeSourceEmitter::defaultEmitInstExpr(IRInst* inst, const EmitOpInfo& inO auto base = ii->getBase(); emitOperand(base, leftSide(outerPrec, prec)); m_writer->emit("."); - if(getSourceStyle() == SourceStyle::GLSL + if(getSourceLanguage() == SourceLanguage::GLSL && as(base->getDataType())) { m_writer->emit("_data."); @@ -2120,7 +2120,7 @@ void CLikeSourceEmitter::defaultEmitInstExpr(IRInst* inst, const EmitOpInfo& inO { auto base = inst->getOperand(0); emitOperand(base, outerPrec); - if(getSourceStyle() == SourceStyle::GLSL + if(getSourceLanguage() == SourceLanguage::GLSL && as(base->getDataType())) { m_writer->emit("._data"); @@ -3240,7 +3240,7 @@ void CLikeSourceEmitter::emitStruct(IRStructType* structType) continue; // Note: GLSL doesn't support interpolation modifiers on `struct` fields - if( getSourceStyle() != SourceStyle::GLSL ) + if( getSourceLanguage() != SourceLanguage::GLSL ) { emitInterpolationModifiers(fieldKey, fieldType, nullptr); } @@ -3455,9 +3455,9 @@ void CLikeSourceEmitter::emitGlobalVar(IRGlobalVar* varDecl) // shader parameter) may need special // modifiers to indicate it as such. // - switch (getSourceStyle()) + switch (getSourceLanguage()) { - case SourceStyle::HLSL: + case SourceLanguage::HLSL: // HLSL requires the `static` modifier on any // global variables; otherwise they are assumed // to be uniforms. diff --git a/source/slang/slang-emit-c-like.h b/source/slang/slang-emit-c-like.h index bead26db3..453a8dbbf 100644 --- a/source/slang/slang-emit-c-like.h +++ b/source/slang/slang-emit-c-like.h @@ -38,18 +38,6 @@ public: kThreadGroupAxisCount = 3, }; - /// To simplify cases - enum class SourceStyle - { - Unknown, - GLSL, - HLSL, - C, - CPP, - CUDA, - CountOf, - }; - typedef unsigned int ESemanticMask; enum { @@ -113,7 +101,7 @@ public: /// Get the code gen target CodeGenTarget getTarget() { return m_target; } /// Get the source style - SLANG_FORCE_INLINE SourceStyle getSourceStyle() const { return m_sourceStyle; } + SLANG_FORCE_INLINE SourceLanguage getSourceLanguage() const { return m_sourceLanguage; } void noteInternalErrorLoc(SourceLoc loc) { return getSink()->noteInternalErrorLoc(loc); } @@ -298,8 +286,9 @@ public: virtual RefObject* getExtensionTracker() { return nullptr; } - /// Gets a source style for a target. Returns Unknown if not a known target - static SourceStyle getSourceStyle(CodeGenTarget target); + /// Gets a source language for a target for a target. Returns Unknown if not a known target + static SourceLanguage getSourceLanguage(CodeGenTarget target); + /// Gets the default type name for built in scalar types. Different impls may require something different. /// Returns an empty slice if not a built in type static UnownedStringSlice getDefaultBuiltinTypeName(IROp op); @@ -372,8 +361,8 @@ public: // The target language we want to generate code for CodeGenTarget m_target; - // Source style - a simplification of the more nuanced m_target - SourceStyle m_sourceStyle; + // Source language (based on the more nuanced m_target) + SourceLanguage m_sourceLanguage; // Where source is written to SourceWriter* m_writer; diff --git a/source/slang/slang-emit-glsl.cpp b/source/slang/slang-emit-glsl.cpp index 0154f9741..d09c778b9 100644 --- a/source/slang/slang-emit-glsl.cpp +++ b/source/slang/slang-emit-glsl.cpp @@ -49,7 +49,7 @@ void GLSLSourceEmitter::_requireGLSLExtension(const UnownedStringSlice& name) void GLSLSourceEmitter::_requireGLSLVersion(ProfileVersion version) { - if (getSourceStyle() != SourceStyle::GLSL) + if (getSourceLanguage() != SourceLanguage::GLSL) return; m_glslExtensionTracker->requireVersion(version); @@ -553,12 +553,12 @@ void GLSLSourceEmitter::_emitGLSLLayoutQualifiers(IRVarLayout* layout, EmitVarCh { if (!layout) return; - switch (getSourceStyle()) + switch (getSourceLanguage()) { default: return; - case SourceStyle::GLSL: + case SourceLanguage::GLSL: break; } diff --git a/source/slang/slang-emit-hlsl.cpp b/source/slang/slang-emit-hlsl.cpp index f33697045..440b9bc68 100644 --- a/source/slang/slang-emit-hlsl.cpp +++ b/source/slang/slang-emit-hlsl.cpp @@ -135,12 +135,12 @@ void HLSLSourceEmitter::_emitHLSLRegisterSemantics(EmitVarChain* chain, char con auto layout = chain->varLayout; - switch (getSourceStyle()) + switch (getSourceLanguage()) { default: return; - case SourceStyle::HLSL: + case SourceLanguage::HLSL: break; } diff --git a/source/slang/slang-emit.cpp b/source/slang/slang-emit.cpp index 1afca6127..f2552f95d 100644 --- a/source/slang/slang-emit.cpp +++ b/source/slang/slang-emit.cpp @@ -308,7 +308,7 @@ Result linkAndOptimizeIR( // We don't need the legalize pass for C/C++ based types if(options.shouldLegalizeExistentialAndResourceTypes ) -// if (!(sourceStyle == SourceStyle::CPP || sourceStyle == SourceStyle::C)) +// if (!(sourceLanguage == SourceLanguage::CPP || sourceStyle == SourceLanguage::C)) { // The Slang language allows interfaces to be used like // ordinary types (including placing them in constant @@ -646,27 +646,25 @@ SlangResult emitEntryPointSourceFromIR( RefPtr sourceEmitter; - typedef CLikeSourceEmitter::SourceStyle SourceStyle; - - SourceStyle sourceStyle = CLikeSourceEmitter::getSourceStyle(target); - switch (sourceStyle) + SourceLanguage sourceLanguage = CLikeSourceEmitter::getSourceLanguage(target); + switch (sourceLanguage) { - case SourceStyle::CPP: + case SourceLanguage::CPP: { sourceEmitter = new CPPSourceEmitter(desc); break; } - case SourceStyle::GLSL: + case SourceLanguage::GLSL: { sourceEmitter = new GLSLSourceEmitter(desc); break; } - case SourceStyle::HLSL: + case SourceLanguage::HLSL: { sourceEmitter = new HLSLSourceEmitter(desc); break; } - case SourceStyle::CUDA: + case SourceLanguage::CUDA: { sourceEmitter = new CUDASourceEmitter(desc); break; @@ -687,14 +685,14 @@ SlangResult emitEntryPointSourceFromIR( linkingAndOptimizationOptions.sourceEmitter = sourceEmitter; - switch( sourceStyle ) + switch( sourceLanguage ) { default: break; - case SourceStyle::CPP: - case SourceStyle::C: - case SourceStyle::CUDA: + case SourceLanguage::CPP: + case SourceLanguage::C: + case SourceLanguage::CUDA: linkingAndOptimizationOptions.shouldLegalizeExistentialAndResourceTypes = false; break; } @@ -728,43 +726,8 @@ SlangResult emitEntryPointSourceFromIR( // it is time to stitch together the final output. { - Session* session = compileRequest->getSession(); - - // Get the downstream compiler needed for final target - PassThroughMode passThru = getDownstreamCompilerRequiredForTarget(session, targetRequest->target); - - // If nothing was *needed*, we still need some idea of which downstream compiler is going to be used for the - // prelude (the prelude is associated with each specific downstream compiler) - if (passThru == PassThroughMode::None) - { - // TODO(JS): - // NOTE! This makes the *assumption* that if we are outputting source, we don't want the - // prelude for a specific compiler, we are happy to just use the GenericCCpp - // If we didn't do this, we would have to do the work out what's available etc. - // - // This is all a bit unfortunate. The decision to associate preludes on compilers seemed like a good idea, but was perhaps a mistake. - // That it would be simpler if prelude was based on output source type. - passThru = getPreludeDownstreamCompilerForTarget(session, targetRequest->target); - } - else - { - // If a compiler was required that means a downstream compiler *will* be used - // so lookup which specific compiler is used, and use it's prelude - // Currently this distinction is only applicable to C++ - if (passThru == PassThroughMode::GenericCCpp) - { - const SourceLanguage sourceLanguage = (sourceStyle == SourceStyle::C) ? SourceLanguage::C : SourceLanguage::CPP; - // Get the compiler used for the language - DownstreamCompiler* compiler = session->getDefaultDownstreamCompiler(sourceLanguage); - if (compiler) - { - passThru = PassThroughMode(compiler->getDesc().type); - } - } - } - // If there is a prelude emit it - const auto& prelude = compileRequest->getSession()->getDownstreamCompilerPrelude(passThru); + const auto& prelude = compileRequest->getSession()->getPreludeForLanguage(sourceLanguage); if (prelude.getLength() > 0) { sourceWriter.emit(prelude.getUnownedSlice()); diff --git a/source/slang/slang.cpp b/source/slang/slang.cpp index 02c9e25e3..5279b2a40 100644 --- a/source/slang/slang.cpp +++ b/source/slang/slang.cpp @@ -254,20 +254,51 @@ SLANG_NO_THROW void SLANG_MCALL Session::setDownstreamCompilerPrelude( SlangPassThrough inPassThrough, char const* prelude) { - PassThroughMode passThrough = PassThroughMode(inPassThrough); - SLANG_ASSERT(int(passThrough) > int(PassThroughMode::None) && int(passThrough) < int(PassThroughMode::CountOf)); - - m_downstreamCompilerPreludes[int(passThrough)] = prelude; + PassThroughMode downstreamCompiler = PassThroughMode(inPassThrough); + SLANG_ASSERT(int(downstreamCompiler) > int(PassThroughMode::None) && int(downstreamCompiler) < int(PassThroughMode::CountOf)); + const SourceLanguage sourceLanguage = getDefaultSourceLanguageForDownstreamCompiler(downstreamCompiler); + setLanguagePrelude(SlangSourceLanguage(sourceLanguage), prelude); } SLANG_NO_THROW void SLANG_MCALL Session::getDownstreamCompilerPrelude( SlangPassThrough inPassThrough, ISlangBlob** outPrelude) { - PassThroughMode passThrough = PassThroughMode(inPassThrough); - SLANG_ASSERT(int(passThrough) > int(PassThroughMode::None) && int(passThrough) < int(PassThroughMode::CountOf)); + PassThroughMode downstreamCompiler = PassThroughMode(inPassThrough); + SLANG_ASSERT(int(downstreamCompiler) > int(PassThroughMode::None) && int(downstreamCompiler) < int(PassThroughMode::CountOf)); + const SourceLanguage sourceLanguage = getDefaultSourceLanguageForDownstreamCompiler(downstreamCompiler); + getLanguagePrelude(SlangSourceLanguage(sourceLanguage), outPrelude); +} + +SLANG_NO_THROW void SLANG_MCALL Session::setLanguagePrelude( + SlangSourceLanguage inSourceLanguage, + char const* prelude) +{ + SourceLanguage sourceLanguage = SourceLanguage(inSourceLanguage); + SLANG_ASSERT(int(sourceLanguage) > int(SourceLanguage::Unknown) && int(sourceLanguage) < int(SourceLanguage::CountOf)); + + SLANG_ASSERT(sourceLanguage != SourceLanguage::Unknown); - *outPrelude = Slang::StringUtil::createStringBlob(m_downstreamCompilerPreludes[int(passThrough)]).detach(); + if (sourceLanguage != SourceLanguage::Unknown) + { + m_languagePreludes[int(sourceLanguage)] = prelude; + } +} + +SLANG_NO_THROW void SLANG_MCALL Session::getLanguagePrelude( + SlangSourceLanguage inSourceLanguage, + ISlangBlob** outPrelude) +{ + SourceLanguage sourceLanguage = SourceLanguage(inSourceLanguage); + SLANG_ASSERT(int(sourceLanguage) > int(SourceLanguage::Unknown) && int(sourceLanguage) < int(SourceLanguage::CountOf)); + + SLANG_ASSERT(sourceLanguage != SourceLanguage::Unknown); + + *outPrelude = nullptr; + if (sourceLanguage != SourceLanguage::Unknown) + { + *outPrelude = Slang::StringUtil::createStringBlob(m_languagePreludes[int(sourceLanguage)]).detach(); + } } SLANG_NO_THROW const char* SLANG_MCALL Session::getBuildTagString() diff --git a/tools/render-test/slang-support.cpp b/tools/render-test/slang-support.cpp index 3e5cc9a1c..da6ceb010 100644 --- a/tools/render-test/slang-support.cpp +++ b/tools/render-test/slang-support.cpp @@ -265,7 +265,7 @@ static gfx::StageType _translateStage(SlangStage slangStage) { // Add an include of the prelude ComPtr prelude; - session->getDownstreamCompilerPrelude(SLANG_PASS_THROUGH_GENERIC_C_CPP, prelude.writeRef()); + session->getLanguagePrelude(input.sourceLanguage, prelude.writeRef()); String preludeString = StringUtil::getString(prelude); -- cgit v1.2.3