diff options
125 files changed, 2307 insertions, 1399 deletions
diff --git a/build/visual-studio/gfx-unit-test-tool/gfx-unit-test-tool.vcxproj b/build/visual-studio/gfx-unit-test-tool/gfx-unit-test-tool.vcxproj index df2f9b4dd..42e52b22d 100644 --- a/build/visual-studio/gfx-unit-test-tool/gfx-unit-test-tool.vcxproj +++ b/build/visual-studio/gfx-unit-test-tool/gfx-unit-test-tool.vcxproj @@ -304,6 +304,7 @@ <ClCompile Include="..\..\..\tools\gfx-unit-test\gfx-test-util.cpp" />
<ClCompile Include="..\..\..\tools\gfx-unit-test\instanced-draw-tests.cpp" />
<ClCompile Include="..\..\..\tools\gfx-unit-test\link-time-constant.cpp" />
+ <ClCompile Include="..\..\..\tools\gfx-unit-test\link-time-options.cpp" />
<ClCompile Include="..\..\..\tools\gfx-unit-test\mutable-shader-object.cpp" />
<ClCompile Include="..\..\..\tools\gfx-unit-test\nested-parameter-block.cpp" />
<ClCompile Include="..\..\..\tools\gfx-unit-test\precompiled-module-2.cpp" />
@@ -327,6 +328,7 @@ <None Include="..\..\..\tools\gfx-unit-test\format-test-shaders.slang" />
<None Include="..\..\..\tools\gfx-unit-test\graphics-smoke.slang" />
<None Include="..\..\..\tools\gfx-unit-test\link-time-constant.slang" />
+ <None Include="..\..\..\tools\gfx-unit-test\link-time-options.slang" />
<None Include="..\..\..\tools\gfx-unit-test\mutable-shader-object.slang" />
<None Include="..\..\..\tools\gfx-unit-test\nested-parameter-block.slang" />
<None Include="..\..\..\tools\gfx-unit-test\precompiled-module-imported.slang" />
diff --git a/build/visual-studio/gfx-unit-test-tool/gfx-unit-test-tool.vcxproj.filters b/build/visual-studio/gfx-unit-test-tool/gfx-unit-test-tool.vcxproj.filters index 9ab4fb3c4..ddc8b6bd3 100644 --- a/build/visual-studio/gfx-unit-test-tool/gfx-unit-test-tool.vcxproj.filters +++ b/build/visual-studio/gfx-unit-test-tool/gfx-unit-test-tool.vcxproj.filters @@ -68,6 +68,9 @@ <ClCompile Include="..\..\..\tools\gfx-unit-test\link-time-constant.cpp">
<Filter>Source Files</Filter>
</ClCompile>
+ <ClCompile Include="..\..\..\tools\gfx-unit-test\link-time-options.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
<ClCompile Include="..\..\..\tools\gfx-unit-test\mutable-shader-object.cpp">
<Filter>Source Files</Filter>
</ClCompile>
@@ -133,6 +136,9 @@ <None Include="..\..\..\tools\gfx-unit-test\link-time-constant.slang">
<Filter>Source Files</Filter>
</None>
+ <None Include="..\..\..\tools\gfx-unit-test\link-time-options.slang">
+ <Filter>Source Files</Filter>
+ </None>
<None Include="..\..\..\tools\gfx-unit-test\mutable-shader-object.slang">
<Filter>Source Files</Filter>
</None>
diff --git a/build/visual-studio/slang/slang.vcxproj b/build/visual-studio/slang/slang.vcxproj index bc768fb4c..9d0b8d27a 100644 --- a/build/visual-studio/slang/slang.vcxproj +++ b/build/visual-studio/slang/slang.vcxproj @@ -328,6 +328,7 @@ IF EXIST ..\..\..\external\slang-glslang\bin\windows-aarch64\release\slang-glsla <ClInclude Include="..\..\..\source\slang\slang-capability.h" />
<ClInclude Include="..\..\..\source\slang\slang-check-impl.h" />
<ClInclude Include="..\..\..\source\slang\slang-check.h" />
+ <ClInclude Include="..\..\..\source\slang\slang-compiler-options.h" />
<ClInclude Include="..\..\..\source\slang\slang-compiler.h" />
<ClInclude Include="..\..\..\source\slang\slang-container-pool.h" />
<ClInclude Include="..\..\..\source\slang\slang-content-assist-info.h" />
@@ -553,6 +554,7 @@ IF EXIST ..\..\..\external\slang-glslang\bin\windows-aarch64\release\slang-glsla <ClCompile Include="..\..\..\source\slang\slang-check-stmt.cpp" />
<ClCompile Include="..\..\..\source\slang\slang-check-type.cpp" />
<ClCompile Include="..\..\..\source\slang\slang-check.cpp" />
+ <ClCompile Include="..\..\..\source\slang\slang-compiler-options.cpp" />
<ClCompile Include="..\..\..\source\slang\slang-compiler.cpp" />
<ClCompile Include="..\..\..\source\slang\slang-container-pool.cpp" />
<ClCompile Include="..\..\..\source\slang\slang-diagnostics.cpp" />
diff --git a/build/visual-studio/slang/slang.vcxproj.filters b/build/visual-studio/slang/slang.vcxproj.filters index 9f91b13f1..4e241f684 100644 --- a/build/visual-studio/slang/slang.vcxproj.filters +++ b/build/visual-studio/slang/slang.vcxproj.filters @@ -72,6 +72,9 @@ <ClInclude Include="..\..\..\source\slang\slang-check.h">
<Filter>Header Files</Filter>
</ClInclude>
+ <ClInclude Include="..\..\..\source\slang\slang-compiler-options.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
<ClInclude Include="..\..\..\source\slang\slang-compiler.h">
<Filter>Header Files</Filter>
</ClInclude>
@@ -743,6 +746,9 @@ <ClCompile Include="..\..\..\source\slang\slang-check.cpp">
<Filter>Source Files</Filter>
</ClCompile>
+ <ClCompile Include="..\..\..\source\slang\slang-compiler-options.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
<ClCompile Include="..\..\..\source\slang\slang-compiler.cpp">
<Filter>Source Files</Filter>
</ClCompile>
diff --git a/slang-gfx.h b/slang-gfx.h index c3b6e7e3d..fa087b5fa 100644 --- a/slang-gfx.h +++ b/slang-gfx.h @@ -2580,6 +2580,18 @@ public: const ITextureResource::Desc& desc, Size* outSize, Size* outAlignment) = 0; virtual SLANG_NO_THROW Result SLANG_MCALL getTextureRowAlignment(Size* outAlignment) = 0; + + virtual SLANG_NO_THROW Result SLANG_MCALL createShaderObject2( + slang::ISession* slangSession, + slang::TypeReflection* type, + ShaderObjectContainerType container, + IShaderObject** outObject) = 0; + + virtual SLANG_NO_THROW Result SLANG_MCALL createMutableShaderObject2( + slang::ISession* slangSession, + slang::TypeReflection* type, + ShaderObjectContainerType container, + IShaderObject** outObject) = 0; }; #define SLANG_UUID_IDevice \ @@ -824,6 +824,155 @@ extern "C" SLANG_OPTIMIZATION_LEVEL_MAXIMAL, /**< Include optimizations that may take a very long time, or may involve severe space-vs-speed tradeoffs */ }; + // All compiler option names supported by Slang. + namespace slang + { + enum class CompilerOptionName + { + MacroDefine, // stringValue0: macro name; stringValue1: macro value + DepFile, + EntryPointName, + Specialize, + Help, + HelpStyle, + Include, // stringValue: additional include path. + Language, + MatrixLayoutColumn, // bool + MatrixLayoutRow, // bool + ModuleName, // stringValue0: module name. + Output, + Profile, // intValue0: profile + Stage, // intValue0: stage + Target, // intValue0: CodeGenTarget + Version, + WarningsAsErrors, // stringValue0: "all" or comma separated list of warning codes or names. + DisableWarnings, // stringValue0: comma separated list of warning codes or names. + EnableWarning, // stringValue0: warning code or name. + DisableWarning, // stringValue0: warning code or name. + DumpWarningDiagnostics, + InputFilesRemain, + EmitIr, // bool + ReportDownstreamTime, // bool + ReportPerfBenchmark, // bool + SkipSPIRVValidation, // bool + + SourceEmbedStyle, + SourceEmbedName, + SourceEmbedLanguage, + + // Target + + Capability, // intValue0: CapabilityName + DefaultImageFormatUnknown, // bool + DisableDynamicDispatch, // bool + DisableSpecialization, // bool + FloatingPointMode, // intValue0: FloatingPointMode + DebugInformation, // intValue0: DebugInfoLevel + LineDirectiveMode, + Optimization, // intValue0: OptimizationLevel + Obfuscate, // bool + + VulkanBindShift, // intValue0 (lower 8 bits): kind; intValue0(higher bits): set; intValue1: shift + VulkanBindGlobals, // intValue0: index; intValue1: set + VulkanInvertY, // bool + VulkanUseEntryPointName, // bool + VulkanUseGLLayout, // bool + VulkanEmitReflection, // bool + + GLSLForceScalarLayout, // bool + EnableEffectAnnotations, // bool + + EmitSpirvViaGLSL, // bool + EmitSpirvDirectly, // bool + SPIRVCoreGrammarJSON, // stringValue0: json path + + // Downstream + + CompilerPath, + DefaultDownstreamCompiler, + DownstreamArgs, // stringValue0: downstream compiler name. stringValue1: argument list, one per line. + PassThrough, + + // Repro + + DumpRepro, + DumpReproOnError, + ExtractRepro, + LoadRepro, + LoadReproDirectory, + ReproFallbackDirectory, + + // Debugging + + DumpAst, + DumpIntermediatePrefix, + DumpIntermediates, // bool + DumpIr, // bool + DumpIrIds, + PreprocessorOutput, + OutputIncludes, + ReproFileSystem, + SerialIr, // bool + SkipCodeGen, // bool + ValidateIr, // bool + VerbosePaths, + VerifyDebugSerialIr, + NoCodeGen, // Not used. + + // Experimental + + FileSystem, + Heterogeneous, + NoMangle, + AllowGLSL, + + // Internal + + ArchiveType, + CompileStdLib, + Doc, + IrCompression, + LoadStdLib, + ReferenceModule, + SaveStdLib, + SaveStdLibBinSource, + TrackLiveness, + + // Deprecated + ParameterBlocksUseRegisterSpaces, + + CountOfParsableOptions, + + // Used in parsed options only. + DebugInformationFormat, // intValue0: DebugInfoFormat + VulkanBindShiftAll, // intValue0: kind; intValue1: shift + GenerateWholeProgram, // bool + + CountOf, + }; + + enum class CompilerOptionValueKind + { + Int, + String + }; + + struct CompilerOptionValue + { + CompilerOptionValueKind kind = CompilerOptionValueKind::Int; + int32_t intValue0 = 0; + int32_t intValue1 = 0; + const char* stringValue0 = nullptr; + const char* stringValue1 = nullptr; + }; + + struct CompilerOptionEntry + { + CompilerOptionName name; + CompilerOptionValue value; + }; + } + /** A result code for a Slang API operation. This type is generally compatible with the Windows API `HRESULT` type. In particular, negative values indicate @@ -2433,9 +2582,16 @@ extern "C" SLANG_API SlangReflectionVariableLayout* spReflection_getGlobalParamsVarLayout( SlangReflection* reflection); +} #ifdef __cplusplus + +namespace slang +{ + struct ISession; } +SLANG_API slang::ISession* spReflection_GetSession(SlangReflection* reflection); + /* Helper interfaces for C++ users */ namespace slang { @@ -3239,6 +3395,11 @@ namespace slang return spReflection_GetTypeParameterCount((SlangReflection*) this); } + slang::ISession* getSession() + { + return spReflection_GetSession((SlangReflection*)this); + } + TypeParameterReflection* getTypeParameterByIndex(unsigned index) { return (TypeParameterReflection*)spReflection_GetTypeParameterByIndex((SlangReflection*) this, index); @@ -3350,7 +3511,6 @@ namespace slang struct ITypeConformance; struct IGlobalSession; struct IModule; - struct ISession; struct SessionDesc; struct SpecializationArg; @@ -3564,6 +3724,16 @@ namespace slang */ virtual SLANG_NO_THROW SlangResult SLANG_MCALL setSPIRVCoreGrammar( char const* jsonPath) = 0; + + /** Parse slangc command line options into a SessionDesc that can be used to create a session + * with all the compiler options specified in the command line. + * @param argc The number of command line arguments. + * @param argv An input array of command line arguments to parse. + * @param outSessionDesc A pointer to a SessionDesc struct to receive parsed session desc. + * @param outAuxAllocation Auxillary memory allocated to hold data used in the sesion desc. + */ + virtual SLANG_NO_THROW SlangResult SLANG_MCALL parseCommandLineArguments( + int argc, const char* const* argv, SessionDesc* outSessionDesc, ISlangUnknown** outAuxAllocation) = 0; }; #define SLANG_UUID_IGlobalSession IGlobalSession::getTypeGuid() @@ -4215,22 +4385,21 @@ namespace slang /** Whether to force `scalar` layout for glsl shader storage buffers. */ bool forceGLSLScalarBufferLayout = false; + + /** Pointer to an array of compiler option entries, whose size is compilerOptionEntryCount. + */ + CompilerOptionEntry* compilerOptionEntries = nullptr; + + /** Number of additional compiler option entries. + */ + uint32_t compilerOptionEntryCount = 0; + }; typedef uint32_t SessionFlags; enum { - kSessionFlags_None = 0, - - /** Use application-specific policy for semantics of the `shared` keyword. - - This is a legacy/compatibility flag to help an existing Slang client - migrate to new language features, and should *not* be used by other - clients. This feature may be removed in a future release without a - deprecation warning, and this bit may be re-used for another feature. - You have been warned. - */ - kSessionFlag_FalcorCustomSharedKeywordSemantics = 1 << 0, + kSessionFlags_None = 0 }; struct PreprocessorMacroDesc @@ -4270,6 +4439,15 @@ namespace slang bool enableEffectAnnotations = false; bool allowGLSLSyntax = false; + + /** Pointer to an array of compiler option entries, whose size is compilerOptionEntryCount. + */ + CompilerOptionEntry* compilerOptionEntries = nullptr; + + /** Number of additional compiler option entries. + */ + uint32_t compilerOptionEntryCount = 0; + }; enum class ContainerType @@ -4657,6 +4835,15 @@ namespace slang */ virtual SLANG_NO_THROW SlangResult SLANG_MCALL renameEntryPoint( const char* newName, IComponentType** outEntryPoint) = 0; + + /** Link and specify additional compiler options when generating code + * from the linked program. + */ + virtual SLANG_NO_THROW SlangResult SLANG_MCALL linkWithOptions( + IComponentType** outLinkedComponentType, + uint32_t compilerOptionEntryCount, + CompilerOptionEntry* compilerOptionEntries, + ISlangBlob** outDiagnostics = nullptr) = 0; }; #define SLANG_UUID_IComponentType IComponentType::getTypeGuid() diff --git a/source/compiler-core/slang-command-line-args.cpp b/source/compiler-core/slang-command-line-args.cpp index 813d2dd26..b69836030 100644 --- a/source/compiler-core/slang-command-line-args.cpp +++ b/source/compiler-core/slang-command-line-args.cpp @@ -2,7 +2,8 @@ #include "../core/slang-process-util.h" #include "../core/slang-string-escape-util.h" - +#include "../core/slang-string-util.h" +#include "../core/slang-type-text-util.h" #include "slang-core-diagnostics.h" namespace Slang { @@ -63,6 +64,27 @@ bool CommandLineArgs::hasArgs(const char*const* args, Index count) const return true; } +String CommandLineArgs::serialize() +{ + StringBuilder sb; + for (auto& arg : m_args) + sb << arg.value << "\n"; + return sb.produceString(); +} + +void CommandLineArgs::deserialize(String content) +{ + List<UnownedStringSlice> slices; + StringUtil::split(content.getUnownedSlice(), '\n', slices); + for (auto arg : slices) + { + Arg v; + v.value = arg; + v.loc = SourceLoc(); + m_args.add(v); + } +} + /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! CommandLineReader @@ -118,6 +140,24 @@ SlangResult CommandLineReader::expectArg(CommandLineArg& outArg) !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ +DownstreamArgs::DownstreamArgs(CommandLineContext* context) + : m_context(context) +{ + // Add all of the possible names we allow for downstream tools + { + for (Index i = SLANG_PASS_THROUGH_NONE + 1; i < SLANG_PASS_THROUGH_COUNT_OF; ++i) + { + addName(TypeTextUtil::getPassThroughName(SlangPassThrough(i))); + } + + // Generic downstream tool + addName("downstream"); + // Generic downstream linker + addName("linker"); + } +} + + Index DownstreamArgs::addName(const String& name) { Index index = findName(name); diff --git a/source/compiler-core/slang-command-line-args.h b/source/compiler-core/slang-command-line-args.h index b2bd48c61..0c11a3c46 100644 --- a/source/compiler-core/slang-command-line-args.h +++ b/source/compiler-core/slang-command-line-args.h @@ -69,6 +69,9 @@ struct CommandLineArgs //String m_executablePath; ///< Can be optionally be set List<Arg> m_args; ///< The args RefPtr<CommandLineContext> m_context; ///< The context, which mainly has source manager + + String serialize(); + void deserialize(String content); }; struct CommandLineReader @@ -155,18 +158,16 @@ struct DownstreamArgs CommandLineContext* getContext() const { return m_context; } /// Ctor - DownstreamArgs(CommandLineContext* context): - m_context(context) - { - } + DownstreamArgs(CommandLineContext* context); + /// Default ctor - for convenience, should really use with context normally DownstreamArgs() {} + List<Entry> m_entries; ///< All of the entries + protected: Index _findOrAddName(SourceLoc loc, const UnownedStringSlice& name, Flags flags, DiagnosticSink* sink); - List<Entry> m_entries; ///< All of the entries - RefPtr<CommandLineContext> m_context; ///< The context that is being used (primarily for loc tracking) across all entries/args }; diff --git a/source/slang/slang-check-decl.cpp b/source/slang/slang-check-decl.cpp index f1409efe1..3fb2725e2 100644 --- a/source/slang/slang-check-decl.cpp +++ b/source/slang/slang-check-decl.cpp @@ -1687,7 +1687,7 @@ namespace Slang } } - if (getLinkage()->getAllowGLSLInput()) + if (getModuleDecl(varDecl)->hasModifier<GLSLModuleModifier>()) { // If we are in GLSL compatiblity mode, we want to treat all global variables // without any `uniform` modifiers as true global variables by default. diff --git a/source/slang/slang-check-impl.h b/source/slang/slang-check-impl.h index 28ed47c53..3af85b73d 100644 --- a/source/slang/slang-check-impl.h +++ b/source/slang/slang-check-impl.h @@ -563,6 +563,11 @@ namespace Slang return m_sink; } + CompilerOptionSet& getOptionSet() + { + return m_linkage->m_optionSet; + } + // We need to track what has been `import`ed into // the scope of this semantic checking session, // and also to avoid importing the same thing more @@ -975,7 +980,10 @@ namespace Slang : Super(context) {} - + CompilerOptionSet& getOptionSet() + { + return getShared()->getOptionSet(); + } public: // Translate Types diff --git a/source/slang/slang-check-modifier.cpp b/source/slang/slang-check-modifier.cpp index 2627ab8e8..9117eb6ec 100644 --- a/source/slang/slang-check-modifier.cpp +++ b/source/slang/slang-check-modifier.cpp @@ -1162,7 +1162,7 @@ namespace Slang if (auto decl = as<Decl>(syntaxNode)) { auto moduleDecl = getModuleDecl(decl); - bool isGLSLInput = getLinkage()->getAllowGLSLInput(); + bool isGLSLInput = getOptionSet().getBoolOption(CompilerOptionName::AllowGLSL); if (!isGLSLInput && moduleDecl && moduleDecl->findModifier<GLSLModuleModifier>()) isGLSLInput = true; if (!isModifierAllowedOnDecl(isGLSLInput, m->astNodeType, decl)) diff --git a/source/slang/slang-compiler-options.cpp b/source/slang/slang-compiler-options.cpp new file mode 100644 index 000000000..aca5fb8db --- /dev/null +++ b/source/slang/slang-compiler-options.cpp @@ -0,0 +1,226 @@ +#include "slang-compiler-options.h" +#include "slang-compiler.h" + +namespace Slang +{ + void CompilerOptionSet::load(uint32_t count, slang::CompilerOptionEntry* entries) + { + for (uint32_t i = 0; i < count; i++) + { + CompilerOptionValue value; + value.kind = entries[i].value.kind; + value.intValue = entries[i].value.intValue0; + value.intValue2 = entries[i].value.intValue1; + if (value.kind == CompilerOptionValueKind::String) + { + value.stringValue = entries[i].value.stringValue0; + value.stringValue2 = entries[i].value.stringValue1; + } + add(entries[i].name, value); + } + } + + void CompilerOptionSet::buildHash(DigestBuilder<SHA1>& builder) + { + for (auto& kv : options) + { + builder.append(kv.key); + builder.append(kv.value.getCount()); + for (auto& v : kv.value) + { + if (v.kind == CompilerOptionValueKind::Int) + { + builder.append(v.intValue); + } + else + { + builder.append(v.stringValue); + builder.append(v.stringValue2); + } + } + } + } + + bool CompilerOptionSet::allowDuplicate(CompilerOptionName name) + { + switch (name) + { + case CompilerOptionName::Include: + case CompilerOptionName::MacroDefine: + case CompilerOptionName::WarningsAsErrors: + case CompilerOptionName::DisableWarning: + case CompilerOptionName::DisableWarnings: + case CompilerOptionName::EnableWarning: + case CompilerOptionName::Capability: + case CompilerOptionName::DownstreamArgs: + case CompilerOptionName::VulkanBindShift: + case CompilerOptionName::VulkanBindShiftAll: + return true; + } + return false; + } + CompilerOptionValue Slang::CompilerOptionSet::getDefault(CompilerOptionName name) + { + switch (name) + { + case CompilerOptionName::Optimization: + return CompilerOptionValue::fromEnum(OptimizationLevel::Default); + default: + return CompilerOptionValue(); + } + } + + SlangTargetFlags CompilerOptionSet::getTargetFlags() + { + SlangTargetFlags result = 0; + if (getBoolOption(CompilerOptionName::DumpIr)) + result |= SLANG_TARGET_FLAG_DUMP_IR; + if (getBoolOption(CompilerOptionName::GenerateWholeProgram)) + result |= SLANG_TARGET_FLAG_GENERATE_WHOLE_PROGRAM; + if (getBoolOption(CompilerOptionName::EmitSpirvDirectly)) + result |= SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY; + if (getBoolOption(CompilerOptionName::ParameterBlocksUseRegisterSpaces)) + result |= SLANG_TARGET_FLAG_PARAMETER_BLOCKS_USE_REGISTER_SPACES; + return result; + } + + void CompilerOptionSet::setTargetFlags(SlangTargetFlags flags) + { + set(CompilerOptionName::DumpIr, (flags & SLANG_TARGET_FLAG_DUMP_IR) != 0); + set(CompilerOptionName::GenerateWholeProgram, (flags & SLANG_TARGET_FLAG_GENERATE_WHOLE_PROGRAM) != 0); + set(CompilerOptionName::EmitSpirvDirectly, (flags & SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY) != 0); + set(CompilerOptionName::ParameterBlocksUseRegisterSpaces, (flags & SLANG_TARGET_FLAG_PARAMETER_BLOCKS_USE_REGISTER_SPACES) != 0); + } + + void CompilerOptionSet::addTargetFlags(SlangTargetFlags flags) + { + if ((flags & SLANG_TARGET_FLAG_DUMP_IR)) + set(CompilerOptionName::DumpIr, true); + + if ((flags & SLANG_TARGET_FLAG_GENERATE_WHOLE_PROGRAM) != 0) + set(CompilerOptionName::GenerateWholeProgram, true); + + if ((flags & SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY) != 0) + set(CompilerOptionName::EmitSpirvDirectly, true); + + if ((flags & SLANG_TARGET_FLAG_PARAMETER_BLOCKS_USE_REGISTER_SPACES) != 0) + set(CompilerOptionName::ParameterBlocksUseRegisterSpaces, true); + } + MatrixLayoutMode CompilerOptionSet::getMatrixLayoutMode() + { + if (getBoolOption(CompilerOptionName::MatrixLayoutRow)) + return kMatrixLayoutMode_RowMajor; + if (getBoolOption(CompilerOptionName::MatrixLayoutColumn)) + return kMatrixLayoutMode_ColumnMajor; + + return (MatrixLayoutMode)kMatrixLayoutMode_RowMajor; + } + + void CompilerOptionSet::setMatrixLayoutMode(MatrixLayoutMode mode) + { + options.remove(CompilerOptionName::MatrixLayoutColumn); + options.remove(CompilerOptionName::MatrixLayoutRow); + if (mode == kMatrixLayoutMode_ColumnMajor) + set(CompilerOptionName::MatrixLayoutColumn, true); + if (mode == kMatrixLayoutMode_RowMajor) + set(CompilerOptionName::MatrixLayoutRow, true); + } + + Profile CompilerOptionSet::getProfile() + { + if (auto profileRaw = getEnumOption<Profile::RawEnum>(CompilerOptionName::Profile)) + return Profile(profileRaw); + return Profile(); + } + + void CompilerOptionSet::setProfile(Profile profile) + { + set(CompilerOptionName::Profile, (int)profile.raw); + } + + ProfileVersion CompilerOptionSet::getProfileVersion() + { + if (auto profileRaw = getEnumOption<Profile::RawEnum>(CompilerOptionName::Profile)) + return Profile(profileRaw).getVersion(); + return ProfileVersion::Unknown; + } + + void CompilerOptionSet::setProfileVersion(ProfileVersion version) + { + Profile profile; + if (auto profileRaw = getEnumOption<Profile::RawEnum>(CompilerOptionName::Profile)) + profile = Profile(profileRaw); + profile.setVersion(version); + set(CompilerOptionName::Profile, (int)profile.raw); + } + + void CompilerOptionSet::addCapabilityAtom(CapabilityName cap) + { + add(CompilerOptionName::Capability, cap); + } + + List<String> CompilerOptionSet::getDownstreamArgs(String downstreamToolName) + { + List<String> result; + auto downstreamArgsArray = getArray(CompilerOptionName::DownstreamArgs); + for (auto& argSet : downstreamArgsArray) + { + if (argSet.stringValue == downstreamToolName) + { + CommandLineArgs args; + args.deserialize(argSet.stringValue2); + for (auto arg : args.m_args) + result.add(arg.value); + break; + } + } + return result; + } + + void CompilerOptionSet::serialize(SerializedOptionsData* outData) + { + for (auto& option : options) + { + for (auto val : option.value) + { + slang::CompilerOptionEntry entry = {}; + entry.name = option.key; + entry.value.kind = val.kind; + entry.value.intValue0 = val.intValue; + entry.value.intValue1 = val.intValue2; + outData->stringPool.add(val.stringValue); + entry.value.stringValue0 = val.stringValue.getBuffer(); + outData->stringPool.add(val.stringValue2); + entry.value.stringValue1 = val.stringValue.getBuffer(); + outData->entries.add(entry); + } + } + } + + void applySettingsToDiagnosticSink(DiagnosticSink* targetSink, DiagnosticSink* outputSink, CompilerOptionSet& options) + { + auto disableArray = options.getArray(CompilerOptionName::DisableWarning); + for (auto& element : disableArray) + { + overrideDiagnostic(targetSink, outputSink, element.stringValue.getUnownedSlice(), Severity::Warning, Severity::Disable); + } + disableArray = options.getArray(CompilerOptionName::DisableWarnings); + for (auto& element : disableArray) + { + overrideDiagnostics(targetSink, outputSink, element.stringValue.getUnownedSlice(), Severity::Warning, Severity::Disable); + } + auto enableArray = options.getArray(CompilerOptionName::EnableWarning); + for (auto& element : enableArray) + { + overrideDiagnostics(targetSink, outputSink, element.stringValue.getUnownedSlice(), Severity::Warning, Severity::Warning); + } + auto warningsAsErrorsArray = options.getArray(CompilerOptionName::WarningsAsErrors); + for (auto& element : warningsAsErrorsArray) + { + if (element.stringValue == "all") + targetSink->setFlag(DiagnosticSink::Flag::TreatWarningsAsErrors); + else + overrideDiagnostics(targetSink, outputSink, element.stringValue.getUnownedSlice(), Severity::Warning, Severity::Error); + } + } +} diff --git a/source/slang/slang-compiler-options.h b/source/slang/slang-compiler-options.h new file mode 100644 index 000000000..0b35f9a29 --- /dev/null +++ b/source/slang/slang-compiler-options.h @@ -0,0 +1,393 @@ +#ifndef SLANG_COMPILER_OPTIONS_H +#define SLANG_COMPILER_OPTIONS_H + +#include "../../slang.h" +#include "../core/slang-basic.h" +#include "../core/slang-crypto.h" +#include "slang-generated-capability-defs.h" +#include "slang-profile.h" + +namespace Slang +{ + using slang::CompilerOptionName; + using slang::CompilerOptionValueKind; + enum MatrixLayoutMode : SlangMatrixLayoutModeIntegral; + enum class LineDirectiveMode : SlangLineDirectiveModeIntegral; + enum class FloatingPointMode : SlangFloatingPointModeIntegral; + enum class OptimizationLevel : SlangOptimizationLevelIntegral; + enum class DebugInfoLevel : SlangDebugInfoLevelIntegral; + enum class CodeGenTarget : SlangCompileTargetIntegral; + + struct CompilerOptionValue + { + CompilerOptionValueKind kind = CompilerOptionValueKind::Int; + int intValue = 0; + int intValue2 = 0; + String stringValue; + String stringValue2; + + template<typename T> + static CompilerOptionValue fromEnum(T val) + { + static_assert(std::is_enum<T>::value); + CompilerOptionValue value; + value.intValue = (int)val; + value.kind = CompilerOptionValueKind::Int; + return value; + } + + static CompilerOptionValue fromInt(int val) + { + CompilerOptionValue value; + value.intValue = val; + value.kind = CompilerOptionValueKind::Int; + return value; + } + + static CompilerOptionValue fromInt2(int val, int val2) + { + CompilerOptionValue value; + value.intValue = val; + value.intValue2 = val2; + value.kind = CompilerOptionValueKind::Int; + return value; + } + + void unpackInt3(uint8_t& v0, int& v1, int& v2) + { + v0 = intValue >> 24; + v1 = intValue & 0xFFFFFF; + v2 = intValue2; + } + + static CompilerOptionValue fromInt3(uint8_t v0, int v1, int v2) + { + CompilerOptionValue value; + value.intValue = (v0 << 24) + (v1 & 0xFFFFFF); + value.intValue2 = v2; + value.kind = CompilerOptionValueKind::Int; + return value; + } + + static CompilerOptionValue fromString(String val) + { + CompilerOptionValue value; + value.stringValue = val; + value.kind = CompilerOptionValueKind::String; + return value; + } + }; + + struct SerializedOptionsData + { + List<slang::CompilerOptionEntry> entries; + List<String> stringPool; + }; + + struct CompilerOptionSet + { + void load(uint32_t count, slang::CompilerOptionEntry* entries); + + void buildHash(DigestBuilder<SHA1>& builder); + + static bool allowDuplicate(CompilerOptionName name); + + OrderedDictionary<CompilerOptionName, List<CompilerOptionValue>> options; + + bool hasOption(CompilerOptionName name) + { + return options.containsKey(name); + } + + void set(CompilerOptionName name, CompilerOptionValue value) + { + if (auto v = options.tryGetValue(name)) + { + v->clear(); + v->add(value); + return; + } + options[name] = List<CompilerOptionValue>{ value }; + } + + void set(CompilerOptionName name, const List<CompilerOptionValue>& value) + { + if (auto v = options.tryGetValue(name)) + { + v->clear(); + v->addRange(value); + return; + } + options[name] = List<CompilerOptionValue>{ value }; + } + + void add(CompilerOptionName name, CompilerOptionValue value) + { + if (auto v = options.tryGetValue(name)) + { + v->add(value); + return; + } + options[name] = List<CompilerOptionValue>{ value }; + } + + void add(CompilerOptionName name, const List<CompilerOptionValue>& value, bool replaceDuplicate = true) + { + if (auto v = options.tryGetValue(name)) + { + for (auto element : value) + { + Index index = -1; + // We don't deduplicate downstream args. + if (name != CompilerOptionName::DownstreamArgs) + { + v->findFirstIndex([&](const CompilerOptionValue& existingVal) + { + if (existingVal.kind == CompilerOptionValueKind::Int) + return existingVal.intValue == element.intValue; + else + return existingVal.stringValue == element.stringValue; + }); + } + if (index != -1) + { + if (replaceDuplicate) + { + (*v)[index].intValue2 = element.intValue; + (*v)[index].stringValue2 = element.stringValue2; + } + } + else + { + v->add(element); + } + } + return; + } + options[name] = List<CompilerOptionValue>{ value }; + } + + // Copy settings from other, and replace the current setting. + void overrideWith(const CompilerOptionSet& other) + { + for (auto& kv : other.options) + { + if (allowDuplicate(kv.key)) + add(kv.key, kv.value, true); + else + set(kv.key, kv.value); + } + } + + // Copy settings from other, but do not replace the current setting + void inheritFrom(const CompilerOptionSet& other) + { + for (auto& kv : other.options) + { + if (allowDuplicate(kv.key)) + add(kv.key, kv.value, false); + else + { + if (options.containsKey(kv.key)) + continue; + set(kv.key, kv.value); + } + } + } + + void add(CompilerOptionName name, int intVal) + { + add(name, CompilerOptionValue::fromInt(intVal)); + } + void add(CompilerOptionName name, int intVal, int intVal2) + { + add(name, CompilerOptionValue::fromInt2(intVal, intVal2)); + } + void add(CompilerOptionName name, uint8_t intVal, int intVal2, int intVal3) + { + add(name, CompilerOptionValue::fromInt3(intVal, intVal2, intVal3)); + } + void add(CompilerOptionName name, String stringVal) + { + add(name, CompilerOptionValue::fromString(stringVal)); + } + void add(CompilerOptionName name, UnownedStringSlice stringVal) + { + add(name, CompilerOptionValue::fromString(stringVal)); + } + void add(CompilerOptionName name, bool boolVal) + { + add(name, CompilerOptionValue::fromInt(boolVal ? 1 : 0)); + } + + template<typename EnumType> + void add(CompilerOptionName name, EnumType enumVal) + { + static_assert(std::is_enum<EnumType>::value); + add(name, (int)enumVal); + } + + void set(CompilerOptionName name, int intVal) + { + set(name, CompilerOptionValue::fromInt(intVal)); + } + void set(CompilerOptionName name, int intVal1, int intVal2) + { + set(name, CompilerOptionValue::fromInt2(intVal1, intVal2)); + } + void set(CompilerOptionName name, uint8_t intVal1, int intVal2, int intVal3) + { + set(name, CompilerOptionValue::fromInt3(intVal1, intVal2, intVal3)); + } + void set(CompilerOptionName name, String stringVal) + { + set(name, CompilerOptionValue::fromString(stringVal)); + } + void set(CompilerOptionName name, bool boolVal) + { + set(name, CompilerOptionValue::fromInt(boolVal ? 1 : 0)); + } + + template<typename EnumType> + void set(CompilerOptionName name, EnumType enumVal) + { + static_assert(std::is_enum<EnumType>::value); + set(name, (int)enumVal); + } + + static CompilerOptionValue getDefault(CompilerOptionName name); + bool getBoolOption(CompilerOptionName name) + { + if (auto result = options.tryGetValue(name)) + { + SLANG_ASSERT(result->getCount() != 0 && (*result)[0].kind == CompilerOptionValueKind::Int); + return result->getCount() != 0 && (*result)[0].intValue != 0; + } + return getDefault(name).intValue != 0; + } + int getIntOption(CompilerOptionName name) + { + if (auto result = options.tryGetValue(name)) + { + SLANG_ASSERT(result->getCount() != 0 && (*result)[0].kind == CompilerOptionValueKind::Int); + return (*result)[0].intValue; + } + return getDefault(name).intValue != 0; + } + String getStringOption(CompilerOptionName name) + { + if (auto result = options.tryGetValue(name)) + { + SLANG_ASSERT(result->getCount() != 0 && (*result)[0].kind == CompilerOptionValueKind::String); + return (*result)[0].stringValue; + } + return getDefault(name).stringValue; + } + + template<typename EnumType> + EnumType getEnumOption(CompilerOptionName name) + { + static_assert(std::is_enum<EnumType>::value); + return (EnumType)getIntOption(name); + } + ArrayView<CompilerOptionValue> getArray(CompilerOptionName name) + { + if (auto result = options.tryGetValue(name)) + { + return result->getArrayView(); + } + return ArrayView<CompilerOptionValue>(); + } + + CodeGenTarget getTarget() + { + return getEnumOption<CodeGenTarget>(CompilerOptionName::Target); + } + + SlangTargetFlags getTargetFlags(); + void setTargetFlags(SlangTargetFlags flags); + void addTargetFlags(SlangTargetFlags flags); + + MatrixLayoutMode getMatrixLayoutMode(); + + void setMatrixLayoutMode(MatrixLayoutMode mode); + + ProfileVersion getProfileVersion(); + + Profile getProfile(); + void setProfile(Profile profile); + + void setProfileVersion(ProfileVersion version); + + void addCapabilityAtom(CapabilityName cap); + + void addPreprocessorDefine(String name, String value) + { + CompilerOptionValue v; + v.stringValue = name; + v.stringValue2 = value; + v.kind = CompilerOptionValueKind::String; + add(CompilerOptionName::MacroDefine, v); + } + + void addSearchPath(String path) + { + add(CompilerOptionName::Include, String(path)); + } + + bool shouldEmitSPIRVDirectly() + { + return getBoolOption(CompilerOptionName::EmitSpirvDirectly); + } + + bool shouldUseScalarLayout() + { + return getBoolOption(CompilerOptionName::GLSLForceScalarLayout); + } + + bool shouldDumpIntermediates() + { + return getBoolOption(CompilerOptionName::DumpIntermediates); + } + + bool shouldDumpIR() + { + return getBoolOption(CompilerOptionName::DumpIr); + } + + bool shouldObfuscateCode() + { + return getBoolOption(CompilerOptionName::Obfuscate); + } + + FloatingPointMode getFloatingPointMode() + { + return getEnumOption<FloatingPointMode>(CompilerOptionName::FloatingPointMode); + } + + LineDirectiveMode getLineDirectiveMode() + { + return getEnumOption<LineDirectiveMode>(CompilerOptionName::LineDirectiveMode); + } + + OptimizationLevel getOptimizationLevel() + { + return getEnumOption<OptimizationLevel>(CompilerOptionName::Optimization); + } + + DebugInfoLevel getDebugInfoLevel() + { + return getEnumOption<DebugInfoLevel>(CompilerOptionName::DebugInformation); + } + + List<String> getDownstreamArgs(String downstreamToolName); + + void serialize(SerializedOptionsData* outData); + }; + + class DiagnosticSink; + void applySettingsToDiagnosticSink(DiagnosticSink* targetSink, DiagnosticSink* outputSink, CompilerOptionSet& options); + +} + +#endif diff --git a/source/slang/slang-compiler.cpp b/source/slang/slang-compiler.cpp index c77f736bc..c0be68723 100644 --- a/source/slang/slang-compiler.cpp +++ b/source/slang/slang-compiler.cpp @@ -964,13 +964,11 @@ namespace Slang return desc.style == ArtifactStyle::Host; } - static bool _shouldSetEntryPointName(TargetRequest* targetReq) + static bool _shouldSetEntryPointName(TargetProgram* targetProgram) { - if (!isKhronosTarget(targetReq)) + if (!isKhronosTarget(targetProgram->getTargetReq())) return true; - if (!targetReq->getHLSLToVulkanLayoutOptions()) - return false; - if (targetReq->getHLSLToVulkanLayoutOptions()->getUseOriginalEntryPointName()) + if (targetProgram->getOptionSet().getBoolOption(CompilerOptionName::VulkanUseEntryPointName)) return true; return false; } @@ -1102,25 +1100,19 @@ namespace Slang // Set compiler specific args { - auto linkage = getLinkage(); - auto name = TypeTextUtil::getPassThroughName((SlangPassThrough)compilerType); - const Index nameIndex = linkage->m_downstreamArgs.findName(name); - if (nameIndex >= 0) + List<String> downstreamArgs = getTargetProgram()->getOptionSet().getDownstreamArgs(name); + for (const auto& arg : downstreamArgs) { - auto& args = linkage->m_downstreamArgs.getArgsAt(nameIndex); - for (const auto& arg : args.m_args) + // We special case some kinds of args, that can be handled directly + if (arg.startsWith("-I")) { - // We special case some kinds of args, that can be handled directly - if (arg.value.startsWith("-I")) - { - // We handle the -I option, by just adding to the include paths - includePaths.add(arg.value.getUnownedSlice().tail(2)); - } - else - { - compilerSpecificArguments.add(arg.value); - } + // We handle the -I option, by just adding to the include paths + includePaths.add(arg.getUnownedSlice().tail(2)); + } + else + { + compilerSpecificArguments.add(arg); } } } @@ -1150,8 +1142,8 @@ namespace Slang sourceTarget = CodeGenTarget(TypeConvertUtil::getCompileTargetFromSourceLanguage((SlangSourceLanguage)sourceLanguage)); // If it's pass through we accumulate the preprocessor definitions. - for (const auto& define : translationUnit->compileRequest->preprocessorDefinitions) - preprocessorDefinitions.add(define); + for (const auto& define : endToEndReq->getOptionSet().getArray(CompilerOptionName::MacroDefine)) + preprocessorDefinitions.add(define.stringValue, define.stringValue2); for (const auto& define : translationUnit->preprocessorDefinitions) preprocessorDefinitions.add(define); @@ -1229,10 +1221,11 @@ namespace Slang // // That said it's very convenient and provides way to control aspects // of downstream compilation. - - auto linkage = getLinkage(); - for (const auto& define : linkage->preprocessorDefinitions) - preprocessorDefinitions.add(define); + + for (const auto& define : getTargetProgram()->getOptionSet().getArray(CompilerOptionName::MacroDefine)) + { + preprocessorDefinitions.addIfNotExists(define.stringValue, define.stringValue2); + } } @@ -1295,12 +1288,12 @@ namespace Slang // * 'doesn't build into an executable/kernel' // // So in some sense it is a library - if (targetReq->isWholeProgramRequest()) + if (getTargetProgram()->getOptionSet().getBoolOption(CompilerOptionName::GenerateWholeProgram)) { if (compilerType == PassThroughMode::Dxc) { // Can support no entry points on DXC because we can build libraries - profile = targetReq->getTargetProfile(); + profile = Profile(getTargetProgram()->getOptionSet().getEnumOption<Profile::RawEnum>(CompilerOptionName::Profile)); } else { @@ -1318,7 +1311,7 @@ namespace Slang auto entryPoint = getEntryPoint(entryPointIndex); profile = getEffectiveProfile(entryPoint, targetReq); - if (_shouldSetEntryPointName(getTargetReq())) + if (_shouldSetEntryPointName(getTargetProgram())) { options.entryPointName = allocator.allocate(getText(entryPoint->getName())); auto entryPointNameOverride = getProgram()->getEntryPointNameOverride(entryPointIndex); @@ -1356,7 +1349,7 @@ namespace Slang } // Set the matrix layout - options.matrixLayout = SlangMatrixLayoutMode(getTargetReq()->getDefaultMatrixLayoutMode()); + options.matrixLayout = (SlangMatrixLayoutMode)getTargetProgram()->getOptionSet().getMatrixLayoutMode(); } // Set the profile @@ -1394,7 +1387,7 @@ namespace Slang { auto linkage = getLinkage(); - switch (linkage->optimizationLevel) + switch (getTargetProgram()->getOptionSet().getEnumOption<OptimizationLevel>(CompilerOptionName::Optimization)) { case OptimizationLevel::None: options.optimizationLevel = DownstreamCompileOptions::OptimizationLevel::None; break; case OptimizationLevel::Default: options.optimizationLevel = DownstreamCompileOptions::OptimizationLevel::Default; break; @@ -1403,7 +1396,7 @@ namespace Slang default: SLANG_ASSERT(!"Unhandled optimization level"); break; } - switch (linkage->debugInfoLevel) + switch (getTargetProgram()->getOptionSet().getEnumOption<DebugInfoLevel>(CompilerOptionName::DebugInformation)) { case DebugInfoLevel::None: options.debugInfoType = DownstreamCompileOptions::DebugInfoType::None; break; case DebugInfoLevel::Minimal: options.debugInfoType = DownstreamCompileOptions::DebugInfoType::Minimal; break; @@ -1413,7 +1406,7 @@ namespace Slang default: SLANG_ASSERT(!"Unhandled debug level"); break; } - switch( getTargetReq()->getFloatingPointMode()) + switch (getTargetProgram()->getOptionSet().getEnumOption<FloatingPointMode>(CompilerOptionName::FloatingPointMode)) { case FloatingPointMode::Default: options.floatingPointMode = DownstreamCompileOptions::FloatingPointMode::Default; break; case FloatingPointMode::Precise: options.floatingPointMode = DownstreamCompileOptions::FloatingPointMode::Precise; break; @@ -1568,7 +1561,7 @@ namespace Slang return SLANG_OK; } case CodeGenTarget::SPIRV: - if (getTargetReq()->shouldEmitSPIRVDirectly()) + if (getTargetProgram()->getOptionSet().shouldEmitSPIRVDirectly()) { SLANG_RETURN_ON_FAIL(emitSPIRVForEntryPointsDirectly(this, outArtifact)); return SLANG_OK; @@ -1844,12 +1837,11 @@ namespace Slang TargetProgram* targetProgram) { auto program = targetProgram->getProgram(); - auto targetReq = targetProgram->getTargetReq(); // Generate target code any entry points that // have been requested for compilation. auto entryPointCount = program->getEntryPointCount(); - if (targetReq->isWholeProgramRequest()) + if (targetProgram->getOptionSet().getBoolOption(CompilerOptionName::GenerateWholeProgram)) { targetProgram->_createWholeProgramResult(getSink(), this); } @@ -1869,7 +1861,7 @@ namespace Slang bool _shouldWriteSourceLocs(Linkage* linkage) { // If debug information or source manager are not avaiable we can't/shouldn't write out locs - if (linkage->debugInfoLevel == DebugInfoLevel::None || + if (linkage->m_optionSet.getEnumOption<DebugInfoLevel>(CompilerOptionName::DebugInformation) == DebugInfoLevel::None || linkage->getSourceManager() == nullptr) { return false; @@ -1886,8 +1878,8 @@ namespace Slang // Set up options SerialContainerUtil::WriteOptions options; - options.compressionType = linkage->serialCompressionType; - if (linkage->m_obfuscateCode) + options.compressionType = linkage->m_optionSet.getEnumOption<SerialCompressionType>(CompilerOptionName::IrCompression); + if (linkage->m_optionSet.getBoolOption(CompilerOptionName::Obfuscate)) { // If code is obfuscated, we *disable* AST output as it is not obfuscated and will reveal // too much about IR. @@ -1942,7 +1934,7 @@ namespace Slang { auto targetProgram = program->getTargetProgram(targetReq); - if (targetReq->isWholeProgramRequest()) + if (targetProgram->getOptionSet().getBoolOption(CompilerOptionName::GenerateWholeProgram)) { if (auto artifact = targetProgram->getExistingWholeProgramResult()) { @@ -2029,6 +2021,16 @@ namespace Slang return SLANG_OK; } + CompilerOptionSet& EndToEndCompileRequest::getTargetOptionSet(TargetRequest* req) + { + return req->getOptionSet(); + } + + CompilerOptionSet& EndToEndCompileRequest::getTargetOptionSet(Index targetIndex) + { + return m_linkage->targets[targetIndex]->getOptionSet(); + } + SlangResult EndToEndCompileRequest::maybeWriteContainer(const String& fileName) { // If there is no container, or filename, don't write anything @@ -2118,7 +2120,7 @@ namespace Slang // Iterate over all the targets and their outputs for (const auto& targetReq : linkage->targets) { - if (targetReq->isWholeProgramRequest()) + if (compileRequest->getTargetOptionSet(targetReq).getBoolOption(CompilerOptionName::GenerateWholeProgram)) { RefPtr<EndToEndCompileRequest::TargetInfo> targetInfo; if (compileRequest->m_targetInfos.tryGetValue(targetReq, targetInfo)) @@ -2157,7 +2159,7 @@ namespace Slang // and report them as an error. // auto specializationParamCount = program->getSpecializationParamCount(); - if (disableDynamicDispatch && specializationParamCount != 0) + if (getOptionSet().getBoolOption(CompilerOptionName::DisableDynamicDispatch) && specializationParamCount != 0) { auto sink = getSink(); @@ -2193,7 +2195,6 @@ namespace Slang } } - void EndToEndCompileRequest::generateOutput() { generateOutput(getSpecializedGlobalAndEntryPointsComponentType()); @@ -2211,7 +2212,7 @@ namespace Slang { auto targetProgram = program->getTargetProgram(targetReq); - if (targetReq->isWholeProgramRequest()) + if (targetProgram->getOptionSet().getBoolOption(CompilerOptionName::GenerateWholeProgram)) { if (const auto artifact = targetProgram->getExistingWholeProgramResult()) { @@ -2337,85 +2338,43 @@ namespace Slang bool CodeGenContext::shouldValidateIR() { - if (auto endToEndReq = isEndToEndCompile()) - { - if (endToEndReq->getFrontEndReq()->shouldValidateIR) - return true; - } - - return false; + return getTargetProgram()->getOptionSet().getBoolOption(CompilerOptionName::ValidateIr); } bool CodeGenContext::shouldSkipSPIRVValidation() { - if (auto endToEndReq = isEndToEndCompile()) - { - if (endToEndReq->m_skipSPIRVValidation) - return true; - } - - return false; + return getTargetProgram()->getOptionSet().getBoolOption(CompilerOptionName::SkipSPIRVValidation); } bool CodeGenContext::shouldDumpIR() { - if (getTargetReq()->getTargetFlags() & SLANG_TARGET_FLAG_DUMP_IR) - return true; - - if (auto endToEndReq = isEndToEndCompile()) - { - if (endToEndReq->getFrontEndReq()->shouldDumpIR) - return true; - } - - return false; + return getTargetProgram()->getOptionSet().getBoolOption(CompilerOptionName::DumpIr); } bool CodeGenContext::shouldDumpIntermediates() { - if (getTargetReq()->shouldDumpIntermediates()) - return true; - if (auto endToEndReq = isEndToEndCompile()) - { - if (endToEndReq->shouldDumpIntermediates) - return true; - } - return false; + return getTargetProgram()->getOptionSet().getBoolOption(CompilerOptionName::DumpIntermediates); } bool CodeGenContext::shouldTrackLiveness() { - auto endToEndReq = isEndToEndCompile(); - return (endToEndReq && endToEndReq->enableLivenessTracking) || - getTargetReq()->shouldTrackLiveness(); + return getTargetProgram()->getOptionSet().getBoolOption(CompilerOptionName::TrackLiveness); } String CodeGenContext::getIntermediateDumpPrefix() { - if (auto endToEndReq = isEndToEndCompile()) - { - return endToEndReq->m_dumpIntermediatePrefix; - } - return String(); + return getTargetProgram()->getOptionSet().getStringOption(CompilerOptionName::DumpIntermediatePrefix); } bool CodeGenContext::getUseUnknownImageFormatAsDefault() { - if (auto endToEndReq = isEndToEndCompile()) - { - return endToEndReq->useUnknownImageFormatAsDefault; - } - return false; + return getTargetProgram()->getOptionSet().getBoolOption(CompilerOptionName::DefaultImageFormatUnknown); } bool CodeGenContext::isSpecializationDisabled() { - if (auto endToEndReq = isEndToEndCompile()) - { - return endToEndReq->disableSpecialization; - } - return false; + return getTargetProgram()->getOptionSet().getBoolOption(CompilerOptionName::DisableSpecialization); } SLANG_NO_THROW SlangResult SLANG_MCALL Module::serialize(ISlangBlob** outSerializedBlob) diff --git a/source/slang/slang-compiler.h b/source/slang/slang-compiler.h index d93eff0a6..7da003b8a 100755 --- a/source/slang/slang-compiler.h +++ b/source/slang/slang-compiler.h @@ -32,7 +32,7 @@ #include "slang-content-assist-info.h" #include "slang-hlsl-to-vulkan-layout-options.h" - +#include "slang-compiler-options.h" #include "slang-serialize-ir-types.h" #include "../compiler-core/slang-artifact-representation-impl.h" @@ -332,6 +332,14 @@ namespace Slang SlangInt targetIndex, slang::IBlob** outHash) SLANG_OVERRIDE; + SLANG_NO_THROW SlangResult SLANG_MCALL linkWithOptions( + slang::IComponentType** outLinkedComponentType, + uint32_t count, + slang::CompilerOptionEntry* entries, + ISlangBlob** outDiagnostics) override; + + CompilerOptionSet& getOptionSet() { return m_optionSet; } + /// Get the linkage (aka "session" in the public API) for this component type. Linkage* getLinkage() { return m_linkage; } @@ -521,6 +529,8 @@ namespace Slang private: Linkage* m_linkage; + + CompilerOptionSet m_optionSet; // Cache of target-specific programs for each target. Dictionary<TargetRequest*, RefPtr<TargetProgram>> m_targetPrograms; @@ -891,6 +901,15 @@ namespace Slang outDiagnostics); } + virtual SLANG_NO_THROW SlangResult SLANG_MCALL linkWithOptions( + slang::IComponentType** outLinkedComponentType, + uint32_t count, + slang::CompilerOptionEntry* entries, + ISlangBlob** outDiagnostics) override + { + return Super::linkWithOptions(outLinkedComponentType, count, entries, outDiagnostics); + } + SLANG_NO_THROW SlangResult SLANG_MCALL getEntryPointHostCallable( int entryPointIndex, int targetIndex, @@ -1113,6 +1132,15 @@ namespace Slang return Super::link(outLinkedComponentType, outDiagnostics); } + virtual SLANG_NO_THROW SlangResult SLANG_MCALL linkWithOptions( + slang::IComponentType** outLinkedComponentType, + uint32_t count, + slang::CompilerOptionEntry* entries, + ISlangBlob** outDiagnostics) override + { + return Super::linkWithOptions(outLinkedComponentType, count, entries, outDiagnostics); + } + SLANG_NO_THROW SlangResult SLANG_MCALL getEntryPointHostCallable( int entryPointIndex, int targetIndex, @@ -1315,6 +1343,14 @@ namespace Slang return SLANG_OK; } + virtual SLANG_NO_THROW SlangResult SLANG_MCALL linkWithOptions( + slang::IComponentType** outLinkedComponentType, + uint32_t count, + slang::CompilerOptionEntry* entries, + ISlangBlob** outDiagnostics) override + { + return Super::linkWithOptions(outLinkedComponentType, count, entries, outDiagnostics); + } // SLANG_NO_THROW void SLANG_MCALL getEntryPointHash( @@ -1623,67 +1659,15 @@ namespace Slang class TargetRequest : public RefObject { public: - TargetRequest(Linkage* linkage, CodeGenTarget format); - void addTargetFlags(SlangTargetFlags flags) - { - targetFlags |= flags; - } - void setTargetProfile(Slang::Profile profile) - { - targetProfile = profile; - } - void setFloatingPointMode(FloatingPointMode mode) - { - floatingPointMode = mode; - } - void setLineDirectiveMode(LineDirectiveMode mode) - { - lineDirectiveMode = mode; - } - - void setDumpIntermediates(bool value) - { - dumpIntermediates = value; - } - void setForceGLSLScalarBufferLayout(bool value) - { - forceGLSLScalarBufferLayout = value; - } - - void addCapability(CapabilityName capability); - - bool shouldEmitSPIRVDirectly() - { - return isKhronosTarget(this) && ((targetFlags & SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY) != 0); - } - - bool isWholeProgramRequest() - { - return (targetFlags & SLANG_TARGET_FLAG_GENERATE_WHOLE_PROGRAM) != 0; - } - - void setHLSLToVulkanLayoutOptions(HLSLToVulkanLayoutOptions* opts); - - const HLSLToVulkanLayoutOptions* getHLSLToVulkanLayoutOptions() const { return hlslToVulkanLayoutOptions; } - - bool shouldDumpIntermediates() { return dumpIntermediates; } - - void setTrackLiveness(bool enable) { enableLivenessTracking = enable; } - - bool shouldTrackLiveness() { return enableLivenessTracking; } + TargetRequest(const TargetRequest& other); Linkage* getLinkage() { return linkage; } - CodeGenTarget getTarget() { return format; } - Profile getTargetProfile() { return targetProfile; } - FloatingPointMode getFloatingPointMode() { return floatingPointMode; } - LineDirectiveMode getLineDirectiveMode() { return lineDirectiveMode; } - SlangTargetFlags getTargetFlags() { return targetFlags; } - CapabilitySet getTargetCaps(); - bool getForceGLSLScalarBufferLayout() { return forceGLSLScalarBufferLayout; } + Session* getSession(); - MatrixLayoutMode getDefaultMatrixLayoutMode(); + + CodeGenTarget getTarget() { return optionSet.getEnumOption<CodeGenTarget>(CompilerOptionName::Target); } // TypeLayouts created on the fly by reflection API Dictionary<Type*, RefPtr<TypeLayout>> typeLayouts; @@ -1692,27 +1676,24 @@ namespace Slang TypeLayout* getTypeLayout(Type* type); + CompilerOptionSet& getOptionSet() { return optionSet; } + + CapabilitySet getTargetCaps(); + + HLSLToVulkanLayoutOptions* getHLSLToVulkanLayoutOptions(); + private: Linkage* linkage = nullptr; - CodeGenTarget format = CodeGenTarget::Unknown; - SlangTargetFlags targetFlags = kDefaultTargetFlags; - Slang::Profile targetProfile = Slang::Profile(); - FloatingPointMode floatingPointMode = FloatingPointMode::Default; - List<CapabilityName> rawCapabilities; + CompilerOptionSet optionSet; CapabilitySet cookedCapabilities; - LineDirectiveMode lineDirectiveMode = LineDirectiveMode::Default; - bool dumpIntermediates = false; - bool forceGLSLScalarBufferLayout = false; - bool enableLivenessTracking = false; - - RefPtr<HLSLToVulkanLayoutOptions> hlslToVulkanLayoutOptions; ///< Optional vulkan layout options + RefPtr<HLSLToVulkanLayoutOptions> hlslToVulkanOptions; }; /// Given a target request returns which (if any) intermediate source language is required /// to produce it. /// /// If no intermediate source language is required, will return SourceLanguage::Unknown - SourceLanguage getIntermediateSourceLanguageForTarget(TargetRequest* req); + SourceLanguage getIntermediateSourceLanguageForTarget(TargetProgram* req); /// Are resource types "bindless" (implemented as ordinary data) on the given `target`? bool areResourceTypesBindlessOnTarget(TargetRequest* target); @@ -1773,6 +1754,8 @@ namespace Slang public: SLANG_REF_OBJECT_IUNKNOWN_ALL + CompilerOptionSet m_optionSet; + ISlangUnknown* getInterface(const Guid& guid); SLANG_NO_THROW slang::IGlobalSession* SLANG_MCALL getGlobalSession() override; @@ -1857,50 +1840,22 @@ namespace Slang /// Dtor ~Linkage(); - slang::SessionFlags m_flag = 0; - void setFlags(slang::SessionFlags flags) { m_flag = flags; } bool isInLanguageServer() { return contentAssistInfo.checkingMode != ContentAssistCheckingMode::None; } /// Get the parent session for this linkage Session* getSessionImpl() { return m_session; } - bool getEnableEffectAnnotations() - { - return m_enableEffectAnnotations; - } - void setEnableEffectAnnotations(bool value) - { - m_enableEffectAnnotations = value; - } - bool getAllowGLSLInput() - { - return m_allowGLSLInput; - } - void setAllowGLSLInput(bool value) - { - m_allowGLSLInput = value; - } - // Information on the targets we are being asked to // generate code for. List<RefPtr<TargetRequest>> targets; // Directories to search for `#include` files or `import`ed modules - SearchDirectoryList searchDirectories; - - SearchDirectoryList const& getSearchDirectories() { return searchDirectories; } - - // Definitions to provide during preprocessing - Dictionary<String, String> preprocessorDefinitions; + SearchDirectoryList& getSearchDirectories(); // Source manager to help track files loaded SourceManager m_defaultSourceManager; SourceManager* m_sourceManager = nullptr; - - bool m_obfuscateCode = false; - - /// Holds any args that are destined for downstream compilers/tools etc - DownstreamArgs m_downstreamArgs; + RefPtr<CommandLineContext> m_cmdLineContext; // Name pool for looking up names NamePool namePool; @@ -1909,7 +1864,6 @@ namespace Slang ASTBuilder* getASTBuilder() { return m_astBuilder; } - RefPtr<ASTBuilder> m_astBuilder; // Cache for container types. @@ -1939,6 +1893,8 @@ namespace Slang // Counters for allocating sequential IDs to witness tables conforming to each interface type. Dictionary<String, uint32_t> mapInterfaceMangledNameToSequentialIDCounters; + SearchDirectoryList searchDirectoryCache; + // The resulting specialized IR module for each entry point request List<RefPtr<IRModule>> compiledModules; @@ -2043,23 +1999,9 @@ namespace Slang void setFileSystem(ISlangFileSystem* fileSystem); - /// The layout to use for matrices by default (row/column major) - MatrixLayoutMode defaultMatrixLayoutMode = kMatrixLayoutMode_ColumnMajor; - MatrixLayoutMode getDefaultMatrixLayoutMode() { return defaultMatrixLayoutMode; } - - DebugInfoLevel debugInfoLevel = DebugInfoLevel::None; - DebugInfoFormat debugInfoFormat = DebugInfoFormat::Default; - - OptimizationLevel optimizationLevel = OptimizationLevel::Default; - - SerialCompressionType serialCompressionType = SerialCompressionType::VariableByteLite; - DiagnosticSink::Flags diagnosticSinkFlags = 0; bool m_requireCacheFileSystem = false; - bool m_useFalcorCustomSharedKeywordSemantics = false; - bool m_enableEffectAnnotations = false; - bool m_allowGLSLInput = false; // Modules that have been read in with the -r option List<ComPtr<IArtifact>> m_libModules; @@ -2151,17 +2093,6 @@ namespace Slang ISlangFileSystemExt* getFileSystemExt() { return getLinkage()->getFileSystemExt(); } SlangResult loadFile(String const& path, PathInfo& outPathInfo, ISlangBlob** outBlob) { return getLinkage()->loadFile(path, outPathInfo, outBlob); } - bool shouldDumpIR = false; - bool shouldValidateIR = false; - - bool shouldDumpAST = false; - bool shouldDocument = false; - - bool outputPreprocessor = false; - - /// If true will after lexical analysis output the hierarchy of includes to stdout - bool outputIncludes = false; - protected: CompileRequestBase( Linkage* linkage, @@ -2196,9 +2127,6 @@ namespace Slang RefPtr<TranslationUnitRequest> getTranslationUnit(UInt index) { return translationUnits[index]; } - // Compile flags to be shared by all translation units - SlangCompileFlags compileFlags = 0; - // If true then generateIR will serialize out IR, and serialize back in again. Making // serialization a bottleneck or firewall between the front end and the backend bool useSerialIRBottleneck = false; @@ -2206,22 +2134,14 @@ namespace Slang // If true will serialize and de-serialize with debug information bool verifyDebugSerialization = false; + CompilerOptionSet optionSet; + List<RefPtr<FrontEndEntryPointRequest>> m_entryPointReqs; List<RefPtr<FrontEndEntryPointRequest>> const& getEntryPointReqs() { return m_entryPointReqs; } UInt getEntryPointReqCount() { return m_entryPointReqs.getCount(); } FrontEndEntryPointRequest* getEntryPointReq(UInt index) { return m_entryPointReqs[index]; } - // Directories to search for `#include` files or `import`ed modules - // NOTE! That for now these search directories are not settable via the API - // so the search directories on Linkage is used for #include as well as for modules. - SearchDirectoryList searchDirectories; - - SearchDirectoryList const& getSearchDirectories() { return searchDirectories; } - - // Definitions to provide during preprocessing - Dictionary<String, String> preprocessorDefinitions; - void parseTranslationUnit( TranslationUnitRequest* translationUnit); @@ -2421,6 +2341,10 @@ namespace Slang return m_irModuleForLayout; } + CompilerOptionSet& getOptionSet() { return m_optionSet; } + + HLSLToVulkanLayoutOptions* getHLSLToVulkanLayoutOptions() { return m_targetReq->getHLSLToVulkanLayoutOptions(); } + private: RefPtr<IRModule> createIRModuleForLayout(DiagnosticSink* sink); @@ -2433,6 +2357,8 @@ namespace Slang // The computed layout, if it has been generated yet RefPtr<ProgramLayout> m_layout; + CompilerOptionSet m_optionSet; + // Generated compile results for each entry point // in the parent `Program` (indexing matches // the order they are given in the `Program`) @@ -2772,7 +2698,7 @@ namespace Slang virtual SLANG_NO_THROW void SLANG_MCALL setReportPerfBenchmark(bool value) SLANG_OVERRIDE; virtual SLANG_NO_THROW void SLANG_MCALL setSkipSPIRVValidation(bool value) SLANG_OVERRIDE; - void setHLSLToVulkanLayoutOptions(int targetIndex, HLSLToVulkanLayoutOptions* vulkanLayoutOptions); + void setTrackLiveness(bool v); EndToEndCompileRequest( Session* session); @@ -2814,35 +2740,14 @@ namespace Slang /// Source code for the specialization arguments to use for the global specialization parameters of the program. List<String> m_globalSpecializationArgStrings; - bool m_shouldSkipCodegen = false; - // Are we being driven by the command-line `slangc`, and should act accordingly? bool m_isCommandLineCompile = false; - - bool m_reportDownstreamCompileTime = false; - - // If set, will print out compiler performance benchmark results. - bool m_reportPerfBenchmark = false; - - bool m_skipSPIRVValidation = false; String m_diagnosticOutput; - - // If set, will dump the compilation state - String m_dumpRepro; - - /// If set, if a compilation failure occurs will attempt to save off a dump repro with a unique name - bool m_dumpReproOnError = false; - /// A blob holding the diagnostic output ComPtr<ISlangBlob> m_diagnosticOutputBlob; - /// Line directive mode for new targets to be added to this request. - /// This is needed to support the legacy `setLineDirectiveMode` API. - /// We can remove this field if we move to `setTargetLineDirectiveMode`. - LineDirectiveMode m_lineDirectiveMode = LineDirectiveMode::Default; - /// Per-entry-point information not tracked by other compile requests class EntryPointInfo : public RefObject { @@ -2861,9 +2766,14 @@ namespace Slang // the given entry point. Dictionary<Int, String> entryPointOutputPaths; String wholeTargetOutputPath; + CompilerOptionSet targetOptions; }; Dictionary<TargetRequest*, RefPtr<TargetInfo>> m_targetInfos; - + + CompilerOptionSet& getTargetOptionSet(TargetRequest* req); + + CompilerOptionSet& getTargetOptionSet(Index targetIndex); + String m_dependencyOutputPath; /// Writes the modules in a container to the stream @@ -2894,9 +2804,6 @@ namespace Slang DiagnosticSink* getSink() { return &m_sink; } NamePool* getNamePool() { return getLinkage()->getNamePool(); } - void setHLSLToVulkanLayoutOptions(HLSLToVulkanLayoutOptions* hlslToVulkanLayoutOptions) { m_hlslToVulkanLayoutOptions = hlslToVulkanLayoutOptions; } - HLSLToVulkanLayoutOptions* getHLSLToVulkanLayoutOptions() const { return m_hlslToVulkanLayoutOptions; } - FrontEndCompileRequest* getFrontEndReq() { return m_frontEndReq; } ComponentType* getUnspecializedGlobalComponentType() { return getFrontEndReq()->getGlobalComponentType(); } @@ -2917,36 +2824,7 @@ namespace Slang void generateOutput(); - void setTrackLiveness(bool enable); - - // Note: The following settings used to be considered part of the "back-end" compile - // request, but were only being used as part of end-to-end compilation anyway, - // so they were moved here. - // - - // Should we dump intermediate results along the way, for debugging? - bool shouldDumpIntermediates = false; - - // True if liveness tracking is enabled - bool enableLivenessTracking = false; - - // Should R/W images without explicit formats be assumed to have "unknown" format? - // - // The default behavior is to make a best-effort guess as to what format is intended. - // - bool useUnknownImageFormatAsDefault = false; - - // If true will disable generics/existential value specialization pass. - bool disableSpecialization = false; - - // If true will disable generating dynamic dispatch code. - bool disableDynamicDispatch = false; - - // The default IR dumping options -// IRDumpOptions m_irDumpOptions; - - String m_dumpIntermediatePrefix; - + CompilerOptionSet& getOptionSet() { return m_linkage->m_optionSet; } private: String _getWholeProgramPath(TargetRequest* targetReq); @@ -2973,8 +2851,6 @@ namespace Slang RefPtr<ComponentType> m_specializedGlobalComponentType; RefPtr<ComponentType> m_specializedGlobalAndEntryPointsComponentType; List<RefPtr<ComponentType>> m_specializedEntryPoints; - - RefPtr<HLSLToVulkanLayoutOptions> m_hlslToVulkanLayoutOptions; // For output @@ -3103,6 +2979,9 @@ namespace Slang SLANG_NO_THROW SlangResult SLANG_MCALL setSPIRVCoreGrammar(char const* jsonPath) override; + SLANG_NO_THROW SlangResult SLANG_MCALL parseCommandLineArguments( + int argc, const char* const* argv, slang::SessionDesc* outSessionDesc, ISlangUnknown** outAllocation) override; + /// Get the downstream compiler for a transition IDownstreamCompiler* getDownstreamCompiler(CodeGenTarget source, CodeGenTarget target); diff --git a/source/slang/slang-diagnostics.cpp b/source/slang/slang-diagnostics.cpp index 08ab829b9..df8c4c0d2 100644 --- a/source/slang/slang-diagnostics.cpp +++ b/source/slang/slang-diagnostics.cpp @@ -4,10 +4,10 @@ #include "../core/slang-memory-arena.h" #include "../core/slang-dictionary.h" #include "../core/slang-string-util.h" +#include "../core/slang-char-util.h" #include "../compiler-core/slang-name.h" #include "../compiler-core/slang-core-diagnostics.h" - namespace Slang { @@ -60,4 +60,66 @@ const DiagnosticsLookup* getDiagnosticsLookup() return _getDiagnosticLookupSingleton(); } + +SlangResult overrideDiagnostic(DiagnosticSink* sink, DiagnosticSink* outDiagnostic, const UnownedStringSlice& identifier, Severity originalSeverity, Severity overrideSeverity) +{ + auto diagnosticsLookup = getDiagnosticsLookup(); + + const DiagnosticInfo* diagnostic = nullptr; + Int diagnosticId = -1; + + // If it starts with a digit we assume it a number + if (identifier.getLength() > 0 && (CharUtil::isDigit(identifier[0]) || identifier[0] == '-')) + { + if (SLANG_FAILED(StringUtil::parseInt(identifier, diagnosticId))) + { + outDiagnostic->diagnose(SourceLoc(), Diagnostics::unknownDiagnosticName, identifier); + return SLANG_FAIL; + } + + // If we use numbers, we don't worry if we can't find a diagnostic + // and silently ignore. This was the previous behavior, and perhaps + // provides a way to safely disable warnings, without worrying about + // the version of the compiler. + diagnostic = diagnosticsLookup->getDiagnosticById(diagnosticId); + } + else + { + diagnostic = diagnosticsLookup->findDiagnosticByName(identifier); + if (!diagnostic) + { + outDiagnostic->diagnose(SourceLoc(), Diagnostics::unknownDiagnosticName, identifier); + return SLANG_FAIL; + } + diagnosticId = diagnostic->id; + } + + // If we are only allowing certain original severities check it's the right type + if (diagnostic && originalSeverity != Severity::Disable && diagnostic->severity != originalSeverity) + { + // Strictly speaking the diagnostic name is known, but it's not the right severity + // to be converted from, so it is an 'unknown name' in the context of severity... + // Or perhaps we want another diagnostic + outDiagnostic->diagnose(SourceLoc(), Diagnostics::unknownDiagnosticName, identifier); + return SLANG_FAIL; + } + + // Override the diagnostic severity in the sink + sink->overrideDiagnosticSeverity(int(diagnosticId), overrideSeverity, diagnostic); + + return SLANG_OK; +} + +SlangResult overrideDiagnostics(DiagnosticSink* sink, DiagnosticSink* outDiagnostic, const UnownedStringSlice& identifierList, Severity originalSeverity, Severity overrideSeverity) +{ + List<UnownedStringSlice> slices; + StringUtil::split(identifierList, ',', slices); + + for (const auto& slice : slices) + { + SLANG_RETURN_ON_FAIL(overrideDiagnostic(sink, outDiagnostic, slice, originalSeverity, overrideSeverity)); + } + return SLANG_OK; +} + } // namespace Slang diff --git a/source/slang/slang-diagnostics.h b/source/slang/slang-diagnostics.h index 917187007..299b63827 100644 --- a/source/slang/slang-diagnostics.h +++ b/source/slang/slang-diagnostics.h @@ -14,6 +14,8 @@ namespace Slang { DiagnosticInfo const* findDiagnosticByName(UnownedStringSlice const& name); const DiagnosticsLookup* getDiagnosticsLookup(); + SlangResult overrideDiagnostic(DiagnosticSink* sink, DiagnosticSink* outDiagnostic, const UnownedStringSlice& identifier, Severity originalSeverity, Severity overrideSeverity); + SlangResult overrideDiagnostics(DiagnosticSink* sink, DiagnosticSink* outDiagnostic, const UnownedStringSlice& identifierList, Severity originalSeverity, Severity overrideSeverity); namespace Diagnostics { diff --git a/source/slang/slang-emit-cpp.cpp b/source/slang/slang-emit-cpp.cpp index 58c635d90..48832f497 100644 --- a/source/slang/slang-emit-cpp.cpp +++ b/source/slang/slang-emit-cpp.cpp @@ -1795,7 +1795,7 @@ void CPPSourceEmitter::_getExportStyle(IRInst* inst, bool& outIsExport, bool& ou outIsExport = false; outIsExternC = false; // Specially handle export, as we don't want to emit it multiple times - if (getTargetReq()->isWholeProgramRequest()) + if (getTargetProgram()->getOptionSet().getBoolOption(CompilerOptionName::GenerateWholeProgram)) { if (auto nameHint = inst->findDecoration<IRNameHintDecoration>()) { diff --git a/source/slang/slang-emit-glsl.cpp b/source/slang/slang-emit-glsl.cpp index e394804c7..55f6d140c 100644 --- a/source/slang/slang-emit-glsl.cpp +++ b/source/slang/slang-emit-glsl.cpp @@ -54,7 +54,7 @@ SlangResult GLSLSourceEmitter::init() default: break; } - if (getTargetReq()->getForceGLSLScalarBufferLayout()) + if (getTargetProgram()->getOptionSet().shouldUseScalarLayout()) { m_glslExtensionTracker->requireExtension( UnownedStringSlice::fromLiteral("GL_EXT_scalar_block_layout")); @@ -128,7 +128,7 @@ void GLSLSourceEmitter::_emitGLSLStructuredBuffer(IRGlobalParam* varDecl, IRHLSL switch (layoutTypeOp) { case kIROp_DefaultBufferLayoutType: - m_writer->emit(getTargetReq()->getForceGLSLScalarBufferLayout() ? "scalar" : "std430"); + m_writer->emit(getTargetProgram()->getOptionSet().shouldUseScalarLayout() ? "scalar" : "std430"); break; case kIROp_Std430BufferLayoutType: m_writer->emit("std430"); @@ -241,14 +241,14 @@ void GLSLSourceEmitter::emitSSBOHeader(IRGlobalParam* varDecl, IRType* bufferTyp if (layoutOp == kIROp_DefaultBufferLayoutType) { - m_writer->emit(getTargetReq()->getForceGLSLScalarBufferLayout() ? "scalar" : "std430"); + m_writer->emit(getTargetProgram()->getOptionSet().shouldUseScalarLayout() ? "scalar" : "std430"); } else { switch (layoutOp) { case kIROp_DefaultBufferLayoutType: - m_writer->emit(getTargetReq()->getForceGLSLScalarBufferLayout() ? "scalar" : "std430"); + m_writer->emit(getTargetProgram()->getOptionSet().shouldUseScalarLayout() ? "scalar" : "std430"); break; case kIROp_Std430BufferLayoutType: m_writer->emit("std430"); @@ -391,7 +391,7 @@ void GLSLSourceEmitter::_emitGLSLParameterGroup(IRGlobalParam* varDecl, IRUnifor { // Is writable m_writer->emit("layout("); - m_writer->emit(getTargetReq()->getForceGLSLScalarBufferLayout() ? "scalar" : "std430"); + m_writer->emit(getTargetProgram()->getOptionSet().shouldUseScalarLayout() ? "scalar" : "std430"); m_writer->emit(") buffer "); } // TODO: what to do with HLSL `tbuffer` style buffers? @@ -399,7 +399,7 @@ void GLSLSourceEmitter::_emitGLSLParameterGroup(IRGlobalParam* varDecl, IRUnifor { // uniform is implicitly read only m_writer->emit("layout("); - m_writer->emit(getTargetReq()->getForceGLSLScalarBufferLayout() ? "scalar" : "std140"); + m_writer->emit(getTargetProgram()->getOptionSet().shouldUseScalarLayout() ? "scalar" : "std140"); m_writer->emit(") uniform "); } @@ -2196,7 +2196,7 @@ void GLSLSourceEmitter::emitFrontMatterImpl(TargetRequest* targetReq) // calls them, because what they call "columns" // are what we call "rows." // - switch (targetReq->getDefaultMatrixLayoutMode()) + switch (getTargetProgram()->getOptionSet().getMatrixLayoutMode()) { case kMatrixLayoutMode_RowMajor: default: diff --git a/source/slang/slang-emit-hlsl.cpp b/source/slang/slang-emit-hlsl.cpp index 416e8b0a1..fcab737e1 100644 --- a/source/slang/slang-emit-hlsl.cpp +++ b/source/slang/slang-emit-hlsl.cpp @@ -755,7 +755,7 @@ static bool _canEmitExport(const Profile& profile) /* virtual */void HLSLSourceEmitter::emitFuncDecorationsImpl(IRFunc* func) { // Specially handle export, as we don't want to emit it multiple times - if (getTargetReq()->isWholeProgramRequest() && + if (getTargetProgram()->getOptionSet().getBoolOption(CompilerOptionName::GenerateWholeProgram) && _canEmitExport(m_effectiveProfile)) { for (auto decoration : func->getDecorations()) @@ -1260,7 +1260,7 @@ void HLSLSourceEmitter::handleRequiredCapabilitiesImpl(IRInst* inst) } } -void HLSLSourceEmitter::emitFrontMatterImpl(TargetRequest* targetReq) +void HLSLSourceEmitter::emitFrontMatterImpl(TargetRequest*) { if (m_extensionTracker->m_requiresNVAPI) { @@ -1314,7 +1314,7 @@ void HLSLSourceEmitter::emitFrontMatterImpl(TargetRequest* targetReq) // Emit any layout declarations - switch (targetReq->getDefaultMatrixLayoutMode()) + switch (getTargetProgram()->getOptionSet().getMatrixLayoutMode()) { case kMatrixLayoutMode_RowMajor: default: diff --git a/source/slang/slang-emit-spirv.cpp b/source/slang/slang-emit-spirv.cpp index d5d00e417..784ded1c9 100644 --- a/source/slang/slang-emit-spirv.cpp +++ b/source/slang/slang-emit-spirv.cpp @@ -1291,9 +1291,7 @@ struct SPIRVEmitContext bool shouldEmitSPIRVReflectionInfo() { - if (!m_targetRequest->getHLSLToVulkanLayoutOptions()) - return false; - return m_targetRequest->getHLSLToVulkanLayoutOptions()->shouldEmitSPIRVReflectionInfo(); + return m_targetProgram->getOptionSet().getBoolOption(CompilerOptionName::VulkanEmitReflection); } void requireVariablePointers() @@ -1401,7 +1399,7 @@ struct SPIRVEmitContext if (m_decoratedSpvInsts.add(getID(resultSpvType))) { IRSizeAndAlignment sizeAndAlignment; - getNaturalSizeAndAlignment(m_targetRequest, ptrType->getValueType(), &sizeAndAlignment); + getNaturalSizeAndAlignment(m_targetProgram->getOptionSet(), ptrType->getValueType(), &sizeAndAlignment); emitOpDecorateArrayStride( getSection(SpvLogicalSectionID::Annotations), nullptr, @@ -1465,7 +1463,7 @@ struct SPIRVEmitContext else { IRSizeAndAlignment sizeAndAlignment; - getNaturalSizeAndAlignment(m_targetRequest, elementType, &sizeAndAlignment); + getNaturalSizeAndAlignment(m_targetProgram->getOptionSet(), elementType, &sizeAndAlignment); stride = (int)sizeAndAlignment.getStride(); } emitOpDecorateArrayStride( @@ -3182,7 +3180,7 @@ struct SPIRVEmitContext } else { - getOffset(m_targetRequest, IRTypeLayoutRules::get(layoutRuleName), field, &offset); + getOffset(m_targetProgram->getOptionSet(), IRTypeLayoutRules::get(layoutRuleName), field, &offset); } emitOpMemberDecorateOffset( getSection(SpvLogicalSectionID::Annotations), @@ -3207,7 +3205,7 @@ struct SPIRVEmitContext IRIntegerValue matrixStride = 0; auto rule = IRTypeLayoutRules::get(layoutRuleName); IRSizeAndAlignment elementSizeAlignment; - getSizeAndAlignment(m_targetRequest, rule, matrixType->getElementType(), &elementSizeAlignment); + getSizeAndAlignment(m_targetProgram->getOptionSet(), rule, matrixType->getElementType(), &elementSizeAlignment); // Reminder: the meaning of row/column major layout // in our semantics is the *opposite* of what GLSL/SPIRV @@ -4153,7 +4151,7 @@ struct SPIRVEmitContext if (ptrType && ptrType->getAddressSpace() == SpvStorageClassPhysicalStorageBuffer) { IRSizeAndAlignment sizeAndAlignment; - getNaturalSizeAndAlignment(m_targetRequest, ptrType->getValueType(), &sizeAndAlignment); + getNaturalSizeAndAlignment(m_targetProgram->getOptionSet(), ptrType->getValueType(), &sizeAndAlignment); return emitOpLoadAligned(parent, inst, inst->getDataType(), inst->getPtr(), SpvLiteralInteger::from32(sizeAndAlignment.alignment)); } else @@ -4168,7 +4166,7 @@ struct SPIRVEmitContext if (ptrType && ptrType->getAddressSpace() == SpvStorageClassPhysicalStorageBuffer) { IRSizeAndAlignment sizeAndAlignment; - getNaturalSizeAndAlignment(m_targetRequest, ptrType->getValueType(), &sizeAndAlignment); + getNaturalSizeAndAlignment(m_targetProgram->getOptionSet(), ptrType->getValueType(), &sizeAndAlignment); return emitOpStoreAligned(parent, inst, inst->getPtr(), inst->getVal(), SpvLiteralInteger::from32(sizeAndAlignment.alignment)); } else @@ -5223,8 +5221,8 @@ struct SPIRVEmitContext } } - SPIRVEmitContext(IRModule* module, TargetRequest* target, DiagnosticSink* sink) - : SPIRVEmitSharedContext(module, target, sink) + SPIRVEmitContext(IRModule* module, TargetProgram* program, DiagnosticSink* sink) + : SPIRVEmitSharedContext(module, program, sink) , m_irModule(module) , m_memoryArena(2048) { @@ -5239,7 +5237,6 @@ SlangResult emitSPIRVFromIR( { spirvOut.clear(); - auto targetRequest = codeGenContext->getTargetReq(); auto sink = codeGenContext->getSink(); #if 0 @@ -5254,7 +5251,7 @@ SlangResult emitSPIRVFromIR( } #endif - SPIRVEmitContext context(irModule, targetRequest, sink); + SPIRVEmitContext context(irModule, codeGenContext->getTargetProgram(), sink); legalizeIRForSPIRV(&context, irModule, irEntryPoints, codeGenContext); #if 0 diff --git a/source/slang/slang-emit.cpp b/source/slang/slang-emit.cpp index 311fce83d..763d96840 100644 --- a/source/slang/slang-emit.cpp +++ b/source/slang/slang-emit.cpp @@ -214,6 +214,7 @@ Result linkAndOptimizeIR( auto sink = codeGenContext->getSink(); auto target = codeGenContext->getTargetFormat(); auto targetRequest = codeGenContext->getTargetReq(); + auto targetProgram = codeGenContext->getTargetProgram(); // Get the artifact desc for the target const auto artifactDesc = ArtifactDescUtil::makeDescForCompileTarget(asExternal(target)); @@ -234,7 +235,6 @@ Result linkAndOptimizeIR( dumpIRIfEnabled(codeGenContext, irModule, "LINKED"); #endif - validateIRModuleIfEnabled(codeGenContext, irModule); // If the user specified the flag that they want us to dump @@ -351,7 +351,7 @@ Result linkAndOptimizeIR( case CodeGenTarget::HostCPPSource: { lowerComInterfaces(irModule, artifactDesc.style, sink); - generateDllImportFuncs(codeGenContext->getTargetReq(), irModule, sink); + generateDllImportFuncs(codeGenContext->getTargetProgram(), irModule, sink); generateDllExportFuncs(irModule, sink); break; } @@ -367,12 +367,12 @@ Result linkAndOptimizeIR( validateIRModuleIfEnabled(codeGenContext, irModule); // Lower all the LValue implict casts (used for out/inout/ref scenarios) - lowerLValueCast(targetRequest, irModule); + lowerLValueCast(targetProgram, irModule); - simplifyIR(targetRequest, irModule, IRSimplificationOptions::getDefault(), sink); + simplifyIR(targetProgram, irModule, IRSimplificationOptions::getDefault(), sink); // Fill in default matrix layout into matrix types that left layout unspecified. - specializeMatrixLayout(codeGenContext->getTargetReq(), irModule); + specializeMatrixLayout(codeGenContext->getTargetProgram(), irModule); // It's important that this takes place before defunctionalization as we // want to be able to easily discover the cooperate and fallback funcitons @@ -406,14 +406,12 @@ Result linkAndOptimizeIR( for (;;) { bool changed = false; - //auto b1 = dumpIRToString(irModule->getModuleInst()); dumpIRIfEnabled(codeGenContext, irModule, "BEFORE-SPECIALIZE"); if (!codeGenContext->isSpecializationDisabled()) - changed |= specializeModule(codeGenContext->getTargetReq(), irModule, codeGenContext->getSink()); + changed |= specializeModule(targetProgram, irModule, codeGenContext->getSink()); if (codeGenContext->getSink()->getErrorCount() != 0) return SLANG_FAIL; dumpIRIfEnabled(codeGenContext, irModule, "AFTER-SPECIALIZE"); - //auto b2 = dumpIRToString(irModule->getModuleInst()); applySparseConditionalConstantPropagation(irModule, codeGenContext->getSink()); eliminateDeadCode(irModule); @@ -427,7 +425,7 @@ Result linkAndOptimizeIR( // Unroll loops. if (codeGenContext->getSink()->getErrorCount() == 0) { - if (!unrollLoopsInModule(targetRequest, irModule, codeGenContext->getSink())) + if (!unrollLoopsInModule(targetProgram, irModule, codeGenContext->getSink())) return SLANG_FAIL; } @@ -440,7 +438,7 @@ Result linkAndOptimizeIR( dumpIRIfEnabled(codeGenContext, irModule, "BEFORE-AUTODIFF"); enableIRValidationAtInsert(); - changed |= processAutodiffCalls(targetRequest, irModule, sink); + changed |= processAutodiffCalls(targetProgram, irModule, sink); disableIRValidationAtInsert(); dumpIRIfEnabled(codeGenContext, irModule, "AFTER-AUTODIFF"); @@ -448,7 +446,7 @@ Result linkAndOptimizeIR( break; } - finalizeAutoDiffPass(targetRequest, irModule); + finalizeAutoDiffPass(targetProgram, irModule); finalizeSpecialization(irModule); @@ -479,11 +477,11 @@ Result linkAndOptimizeIR( SLANG_RETURN_ON_FAIL(performStringInlining(irModule, sink)); } - lowerReinterpret(targetRequest, irModule, sink); + lowerReinterpret(targetProgram, irModule, sink); validateIRModuleIfEnabled(codeGenContext, irModule); - simplifyIR(targetRequest, irModule, IRSimplificationOptions::getFast(), sink); + simplifyIR(targetProgram, irModule, IRSimplificationOptions::getFast(), sink); if (!ArtifactDescUtil::isCpuLikeTarget(artifactDesc)) { @@ -495,7 +493,7 @@ Result linkAndOptimizeIR( // generics / interface types to ordinary functions and types using // function pointers. dumpIRIfEnabled(codeGenContext, irModule, "BEFORE-LOWER-GENERICS"); - lowerGenerics(targetRequest, irModule, sink); + lowerGenerics(targetProgram, irModule, sink); dumpIRIfEnabled(codeGenContext, irModule, "AFTER-LOWER-GENERICS"); if (sink->getErrorCount() != 0) @@ -512,7 +510,7 @@ Result linkAndOptimizeIR( // up downstream passes like type legalization, so we // will run a DCE pass to clean up after the specialization. // - simplifyIR(targetRequest, irModule, IRSimplificationOptions::getDefault(), sink); + simplifyIR(targetProgram, irModule, IRSimplificationOptions::getDefault(), sink); validateIRModuleIfEnabled(codeGenContext, irModule); @@ -521,7 +519,7 @@ Result linkAndOptimizeIR( // of `RWStructuredBuffer` typed fields now. if (target != CodeGenTarget::HLSL) { - lowerAppendConsumeStructuredBuffers(targetRequest, irModule, sink); + lowerAppendConsumeStructuredBuffers(targetProgram, irModule, sink); } // We don't need the legalize pass for C/C++ based types @@ -598,7 +596,7 @@ Result linkAndOptimizeIR( // to see if we can clean up any temporaries created by legalization. // (e.g., things that used to be aggregated might now be split up, // so that we can work with the individual fields). - simplifyIR(targetRequest, irModule, IRSimplificationOptions::getFast(), sink); + simplifyIR(targetProgram, irModule, IRSimplificationOptions::getFast(), sink); #if 0 dumpIRIfEnabled(codeGenContext, irModule, "AFTER SSA"); @@ -721,7 +719,7 @@ Result linkAndOptimizeIR( { case CodeGenTarget::HLSL: { - auto profile = targetRequest->getTargetProfile(); + auto profile = codeGenContext->getTargetProgram()->getOptionSet().getProfile(); if( profile.getFamily() == ProfileFamily::DX ) { if(profile.getVersion() <= ProfileVersion::DX_5_0) @@ -742,7 +740,7 @@ Result linkAndOptimizeIR( break; } - legalizeByteAddressBufferOps(session, targetRequest, irModule, byteAddressBufferOptions); + legalizeByteAddressBufferOps(session, targetProgram, irModule, byteAddressBufferOptions); } // For CUDA targets only, we will need to turn operations @@ -909,7 +907,7 @@ Result linkAndOptimizeIR( { // We need to lower any types used in a buffer resource (e.g. ContantBuffer or StructuredBuffer) into // a simple storage type that has target independent layout based on the kind of buffer resource. - lowerBufferElementTypeToStorageType(targetRequest, irModule); + lowerBufferElementTypeToStorageType(targetProgram, irModule); } // Rewrite functions that return arrays to return them via `out` parameter, @@ -919,20 +917,21 @@ Result linkAndOptimizeIR( if (isKhronosTarget(targetRequest) || target == CodeGenTarget::HLSL) { legalizeUniformBufferLoad(irModule); - if (targetRequest->getHLSLToVulkanLayoutOptions() && targetRequest->getHLSLToVulkanLayoutOptions()->shouldInvertY()) + if (targetProgram->getOptionSet().getBoolOption(CompilerOptionName::VulkanInvertY)) invertYOfPositionOutput(irModule); } // Lower sizeof/alignof - lowerSizeOfLike(targetRequest, irModule, sink); + lowerSizeOfLike(targetProgram, irModule, sink); // Lower all bit_cast operations on complex types into leaf-level // bit_cast on basic types. - lowerBitCast(targetRequest, irModule); + lowerBitCast(targetProgram, irModule); + bool emitSpirvDirectly = targetProgram->getOptionSet().shouldEmitSPIRVDirectly(); - if (isKhronosTarget(targetRequest) && targetRequest->shouldEmitSPIRVDirectly()) + if (isKhronosTarget(targetRequest) && emitSpirvDirectly) { performIntrinsicFunctionInlining(irModule); eliminateDeadCode(irModule); @@ -942,7 +941,7 @@ Result linkAndOptimizeIR( { IRSimplificationOptions simplificationOptions = IRSimplificationOptions::getFast(); simplificationOptions.cfgOptions.removeTrivialSingleIterationLoops = true; - simplifyIR(targetRequest, irModule, simplificationOptions, sink); + simplifyIR(targetProgram, irModule, simplificationOptions, sink); } // As a late step, we need to take the SSA-form IR and move things *out* @@ -971,7 +970,7 @@ Result linkAndOptimizeIR( // We only want to accumulate locations if liveness tracking is enabled. PhiEliminationOptions phiEliminationOptions; - if (isKhronosTarget(targetRequest) && targetRequest->shouldEmitSPIRVDirectly()) + if (isKhronosTarget(targetRequest) && emitSpirvDirectly) { phiEliminationOptions.eliminateCompositeTypedPhiOnly = false; phiEliminationOptions.useRegisterAllocation = true; @@ -1020,7 +1019,7 @@ Result linkAndOptimizeIR( } // Run a final round of simplifications to clean up unused things after phi-elimination. - simplifyNonSSAIR(targetRequest, irModule, IRSimplificationOptions::getFast()); + simplifyNonSSAIR(targetProgram, irModule, IRSimplificationOptions::getFast()); // We include one final step to (optionally) dump the IR and validate // it after all of the optimization passes are complete. This should @@ -1052,8 +1051,9 @@ SlangResult CodeGenContext::emitEntryPointsSourceFromIR(ComPtr<IArtifact>& outAr auto sourceManager = getSourceManager(); auto target = getTargetFormat(); auto targetRequest = getTargetReq(); + auto targetProgram = getTargetProgram(); - auto lineDirectiveMode = targetRequest->getLineDirectiveMode(); + auto lineDirectiveMode = targetProgram->getOptionSet().getEnumOption<LineDirectiveMode>(CompilerOptionName::LineDirectiveMode); // To try to make the default behavior reasonable, we will // always use C-style line directives (to give the user // good source locations on error messages from downstream @@ -1088,7 +1088,7 @@ SlangResult CodeGenContext::emitEntryPointsSourceFromIR(ComPtr<IArtifact>& outAr else { desc.entryPointStage = Stage::Unknown; - desc.effectiveProfile = targetRequest->getTargetProfile(); + desc.effectiveProfile = targetProgram->getOptionSet().getProfile(); } desc.sourceWriter = &sourceWriter; @@ -1310,8 +1310,7 @@ SlangResult emitSPIRVForEntryPointsDirectly( downstreamOptions.sourceArtifacts = makeSlice(artifact.readRef(), 1); downstreamOptions.targetType = SLANG_SPIRV; downstreamOptions.sourceLanguage = SLANG_SOURCE_LANGUAGE_SPIRV; - auto linkage = codeGenContext->getLinkage(); - switch (linkage->optimizationLevel) + switch (codeGenContext->getTargetProgram()->getOptionSet().getEnumOption<OptimizationLevel>(CompilerOptionName::Optimization)) { case OptimizationLevel::None: downstreamOptions.optimizationLevel = DownstreamCompileOptions::OptimizationLevel::None; break; case OptimizationLevel::Default: downstreamOptions.optimizationLevel = DownstreamCompileOptions::OptimizationLevel::Default; break; diff --git a/source/slang/slang-hlsl-to-vulkan-layout-options.cpp b/source/slang/slang-hlsl-to-vulkan-layout-options.cpp index 36044e43a..0e6f70294 100644 --- a/source/slang/slang-hlsl-to-vulkan-layout-options.cpp +++ b/source/slang/slang-hlsl-to-vulkan-layout-options.cpp @@ -1,6 +1,7 @@ // slang-hlsl-to-vulkan-layout-options.cpp #include "slang-hlsl-to-vulkan-layout-options.h" +#include "slang-compiler-options.h" namespace Slang { @@ -27,6 +28,37 @@ static NamesDescriptionValue s_vulkanShiftKinds[] = return makeConstArrayView(s_vulkanShiftKinds); } +void HLSLToVulkanLayoutOptions::loadFromOptionSet(CompilerOptionSet& optionSet) +{ + auto allShift = optionSet.getArray(CompilerOptionName::VulkanBindShiftAll); + for (auto v : allShift) + { + setAllShift((Kind)v.intValue, v.intValue2); + } + auto shifts = optionSet.getArray(CompilerOptionName::VulkanBindShift); + for (auto v : shifts) + { + uint8_t kind; + int set; + int shift; + v.unpackInt3(kind, set, shift); + setShift((Kind)kind, set, shift); + } + m_emitSPIRVReflectionInfo = optionSet.getBoolOption(CompilerOptionName::VulkanEmitReflection); + if (auto bindGlobals = optionSet.options.tryGetValue(CompilerOptionName::VulkanBindGlobals)) + { + if (bindGlobals->getCount()) + { + m_globalsBinding.index = (*bindGlobals)[0].intValue; + m_globalsBinding.set = (*bindGlobals)[0].intValue2; + } + } + m_invertY = optionSet.getBoolOption(CompilerOptionName::VulkanInvertY); + m_useGLLayout = optionSet.getBoolOption(CompilerOptionName::VulkanUseGLLayout); + m_useOriginalEntryPointName = optionSet.getBoolOption(CompilerOptionName::VulkanUseEntryPointName); + +} + HLSLToVulkanLayoutOptions::HLSLToVulkanLayoutOptions() { // Clear the all shifts diff --git a/source/slang/slang-hlsl-to-vulkan-layout-options.h b/source/slang/slang-hlsl-to-vulkan-layout-options.h index 97de2a610..2b8ec973c 100644 --- a/source/slang/slang-hlsl-to-vulkan-layout-options.h +++ b/source/slang/slang-hlsl-to-vulkan-layout-options.h @@ -15,6 +15,9 @@ https://github.com/microsoft/DirectXShaderCompiler/blob/main/docs/SPIR-V.rst#des Options that allow for infering Vulkan bindings based on HLSL register bindings */ + +struct CompilerOptionSet; + struct HLSLToVulkanLayoutOptions : public RefObject { public: @@ -61,7 +64,7 @@ public: /// Constant buffer (b) /// /// ConstantBufferViews, CBuffer - ConstantBuffer, + ConstantBuffer, CountOf, }; @@ -157,6 +160,8 @@ public: void setEmitSPIRVReflectionInfo(bool value) { m_emitSPIRVReflectionInfo = value; } + void loadFromOptionSet(CompilerOptionSet& optionSet); + /// Ctor HLSLToVulkanLayoutOptions(); diff --git a/source/slang/slang-ir-any-value-inference.cpp b/source/slang/slang-ir-any-value-inference.cpp index ae3e67397..b1e82623f 100644 --- a/source/slang/slang-ir-any-value-inference.cpp +++ b/source/slang/slang-ir-any-value-inference.cpp @@ -86,7 +86,7 @@ namespace Slang } void inferAnyValueSizeWhereNecessary( - TargetRequest* targetReq, + TargetProgram* targetProgram, IRModule* module) { // Go through the global insts and collect all interface types. @@ -213,7 +213,7 @@ namespace Slang for (auto implType : mapInterfaceToImplementations[interfaceType]) { IRSizeAndAlignment sizeAndAlignment; - getNaturalSizeAndAlignment(targetReq, (IRType*)implType, &sizeAndAlignment); + getNaturalSizeAndAlignment(targetProgram->getOptionSet(), (IRType*)implType, &sizeAndAlignment); maxAnyValueSize = Math::Max(maxAnyValueSize, sizeAndAlignment.size); } diff --git a/source/slang/slang-ir-any-value-inference.h b/source/slang/slang-ir-any-value-inference.h index a7911ff23..d1b6702f4 100644 --- a/source/slang/slang-ir-any-value-inference.h +++ b/source/slang/slang-ir-any-value-inference.h @@ -9,6 +9,6 @@ namespace Slang { void inferAnyValueSizeWhereNecessary( - TargetRequest* targetReq, + TargetProgram* targetProgram, IRModule* module); } diff --git a/source/slang/slang-ir-autodiff-fwd.cpp b/source/slang/slang-ir-autodiff-fwd.cpp index 632f99480..2f61dfa72 100644 --- a/source/slang/slang-ir-autodiff-fwd.cpp +++ b/source/slang/slang-ir-autodiff-fwd.cpp @@ -1642,7 +1642,7 @@ SlangResult ForwardDiffTranscriber::prepareFuncForForwardDiff(IRFunc* func) if (SLANG_SUCCEEDED(result)) { disableIRValidationAtInsert(); - simplifyFunc(autoDiffSharedContext->targetRequest, func, IRSimplificationOptions::getDefault()); + simplifyFunc(autoDiffSharedContext->targetProgram, func, IRSimplificationOptions::getDefault()); enableIRValidationAtInsert(); } return result; diff --git a/source/slang/slang-ir-autodiff.cpp b/source/slang/slang-ir-autodiff.cpp index 2605dd028..2cc4e3b57 100644 --- a/source/slang/slang-ir-autodiff.cpp +++ b/source/slang/slang-ir-autodiff.cpp @@ -339,8 +339,8 @@ IRInst* DifferentialPairTypeBuilder::lowerDiffPairType( return result; } -AutoDiffSharedContext::AutoDiffSharedContext(TargetRequest* target, IRModuleInst* inModuleInst) - : moduleInst(inModuleInst), targetRequest(target) +AutoDiffSharedContext::AutoDiffSharedContext(TargetProgram* target, IRModuleInst* inModuleInst) + : moduleInst(inModuleInst), targetProgram(target) { differentiableInterfaceType = as<IRInterfaceType>(findDifferentiableInterface()); if (differentiableInterfaceType) @@ -1979,7 +1979,7 @@ protected: }; bool processAutodiffCalls( - TargetRequest* target, + TargetProgram* target, IRModule* module, DiagnosticSink* sink, IRAutodiffPassOptions const&) @@ -2078,7 +2078,7 @@ void releaseNullDifferentialType(AutoDiffSharedContext* context) } } -bool finalizeAutoDiffPass(TargetRequest* target, IRModule* module) +bool finalizeAutoDiffPass(TargetProgram* target, IRModule* module) { bool modified = false; diff --git a/source/slang/slang-ir-autodiff.h b/source/slang/slang-ir-autodiff.h index a3e8c8de7..811002091 100644 --- a/source/slang/slang-ir-autodiff.h +++ b/source/slang/slang-ir-autodiff.h @@ -59,7 +59,7 @@ struct DiffTranscriberSet struct AutoDiffSharedContext { - TargetRequest* targetRequest = nullptr; + TargetProgram* targetProgram = nullptr; IRModuleInst* moduleInst = nullptr; @@ -115,7 +115,7 @@ struct AutoDiffSharedContext DiffTranscriberSet transcriberSet; - AutoDiffSharedContext(TargetRequest* target, IRModuleInst* inModuleInst); + AutoDiffSharedContext(TargetProgram* target, IRModuleInst* inModuleInst); private: @@ -359,12 +359,12 @@ struct IRAutodiffPassOptions }; bool processAutodiffCalls( - TargetRequest* target, + TargetProgram* target, IRModule* module, DiagnosticSink* sink, IRAutodiffPassOptions const& options = IRAutodiffPassOptions()); -bool finalizeAutoDiffPass(TargetRequest* target, IRModule* module); +bool finalizeAutoDiffPass(TargetProgram* target, IRModule* module); // Utility methods diff --git a/source/slang/slang-ir-byte-address-legalize.cpp b/source/slang/slang-ir-byte-address-legalize.cpp index fd2b599f8..c1e22c89f 100644 --- a/source/slang/slang-ir-byte-address-legalize.cpp +++ b/source/slang/slang-ir-byte-address-legalize.cpp @@ -24,6 +24,7 @@ struct ByteAddressBufferLegalizationContext // that control what constructs we legalize, and how. // Session* m_session = nullptr; + TargetProgram* m_targetProgram = nullptr; TargetRequest* m_target = nullptr; ByteAddressBufferLegalizationOptions m_options; @@ -204,22 +205,22 @@ struct ByteAddressBufferLegalizationContext return false; } - SlangResult getOffset(TargetRequest* target, IRStructField* field, IRIntegerValue* outOffset) + SlangResult getOffset(TargetProgram* target, IRStructField* field, IRIntegerValue* outOffset) { if (target->getHLSLToVulkanLayoutOptions() && target->getHLSLToVulkanLayoutOptions()->shouldUseGLLayout()) { - return getStd430Offset(target, field, outOffset); + return getStd430Offset(target->getOptionSet(), field, outOffset); } - return getNaturalOffset(target, field, outOffset); + return getNaturalOffset(target->getOptionSet(), field, outOffset); } - SlangResult getSizeAndAlignment(TargetRequest* target, IRType* type, IRSizeAndAlignment* outSizeAlignment) + SlangResult getSizeAndAlignment(TargetProgram* target, IRType* type, IRSizeAndAlignment* outSizeAlignment) { if (target->getHLSLToVulkanLayoutOptions() && target->getHLSLToVulkanLayoutOptions()->shouldUseGLLayout()) { - return getStd430SizeAndAlignment(target, type, outSizeAlignment); + return getStd430SizeAndAlignment(target->getOptionSet(), type, outSizeAlignment); } - return getNaturalSizeAndAlignment(target, type, outSizeAlignment); + return getNaturalSizeAndAlignment(target->getOptionSet(), type, outSizeAlignment); } // The core workhorse routine for the load case is `emitLegalLoad`, @@ -275,7 +276,7 @@ struct ByteAddressBufferLegalizationContext // then we fail to legalize this load. // IRIntegerValue fieldOffset = 0; - SLANG_RETURN_NULL_ON_FAIL(getOffset(m_target, field, &fieldOffset)); + SLANG_RETURN_NULL_ON_FAIL(getOffset(m_targetProgram, field, &fieldOffset)); // Otherwise, we load the field by recursively calling this function // on the field type, with an adjusted immediate offset. @@ -338,7 +339,7 @@ struct ByteAddressBufferLegalizationContext auto rowCount = (Index)getIntVal(matType->getRowCount()); auto colVectorType = m_builder.getVectorType(matType->getElementType(), rowCount); IRSizeAndAlignment colVectorSizeAlignment; - getSizeAndAlignment(m_target, colVectorType, &colVectorSizeAlignment); + getSizeAndAlignment(m_targetProgram, colVectorType, &colVectorSizeAlignment); for (Index c = 0; c < colCount; c++) { auto colVector = emitLegalLoad(colVectorType, buffer, baseOffset, immediateOffset); @@ -456,7 +457,7 @@ struct ByteAddressBufferLegalizationContext // the "stride" of the element type. // IRSizeAndAlignment elementLayout; - SLANG_RETURN_NULL_ON_FAIL(getNaturalSizeAndAlignment(m_target, elementType, &elementLayout)); + SLANG_RETURN_NULL_ON_FAIL(getNaturalSizeAndAlignment(m_targetProgram->getOptionSet(), elementType, &elementLayout)); IRIntegerValue elementStride = elementLayout.getStride(); // We will collect all the element values into an array so @@ -546,7 +547,7 @@ struct ByteAddressBufferLegalizationContext auto offsetType = offset->getDataType(); IRSizeAndAlignment typeLayout; - SLANG_RETURN_NULL_ON_FAIL(getNaturalSizeAndAlignment(m_target, type, &typeLayout)); + SLANG_RETURN_NULL_ON_FAIL(getNaturalSizeAndAlignment(m_targetProgram->getOptionSet(), type, &typeLayout)); auto typeStrideVal = typeLayout.getStride(); auto typeStrideInst = m_builder.getIntValue(offsetType, typeStrideVal); @@ -858,7 +859,7 @@ struct ByteAddressBufferLegalizationContext auto fieldType = field->getFieldType(); IRIntegerValue fieldOffset; - SLANG_RETURN_ON_FAIL(getOffset(m_target, field, &fieldOffset)); + SLANG_RETURN_ON_FAIL(getOffset(m_targetProgram, field, &fieldOffset)); auto fieldVal = m_builder.emitFieldExtract(fieldType, value, field->getKey()); SLANG_RETURN_ON_FAIL(emitLegalStore(fieldType, buffer, baseOffset, immediateOffset + fieldOffset, fieldVal)); @@ -907,7 +908,7 @@ struct ByteAddressBufferLegalizationContext auto colVectorType = m_builder.getVectorType(matType->getElementType(), rowCount); auto colVector = m_builder.emitMakeVector(colVectorType, colVectorArgs); IRSizeAndAlignment colVectorSizeAlignment; - getSizeAndAlignment(m_target, colVectorType, &colVectorSizeAlignment); + getSizeAndAlignment(m_targetProgram, colVectorType, &colVectorSizeAlignment); emitLegalStore(colVectorType, buffer, baseOffset, immediateOffset, colVector); immediateOffset += colVectorSizeAlignment.getStride(); } @@ -967,7 +968,7 @@ struct ByteAddressBufferLegalizationContext auto indexType = offset->getDataType(); IRSizeAndAlignment typeLayout; - SLANG_RETURN_ON_FAIL(getNaturalSizeAndAlignment(m_target, type, &typeLayout)); + SLANG_RETURN_ON_FAIL(getNaturalSizeAndAlignment(m_targetProgram->getOptionSet(), type, &typeLayout)); auto typeStride = m_builder.getIntValue(indexType, typeLayout.getStride()); @@ -995,7 +996,7 @@ struct ByteAddressBufferLegalizationContext // We iterate over the elements and fetch then store each one. // IRSizeAndAlignment elementLayout; - SLANG_RETURN_ON_FAIL(getNaturalSizeAndAlignment(m_target, elementType, &elementLayout)); + SLANG_RETURN_ON_FAIL(getNaturalSizeAndAlignment(m_targetProgram->getOptionSet(), elementType, &elementLayout)); IRIntegerValue elementStride = elementLayout.getStride(); auto indexType = m_builder.getIntType(); @@ -1013,14 +1014,15 @@ struct ByteAddressBufferLegalizationContext void legalizeByteAddressBufferOps( Session* session, - TargetRequest* target, + TargetProgram* program, IRModule* module, ByteAddressBufferLegalizationOptions const& options) { ByteAddressBufferLegalizationContext context; context.m_session = session; - context.m_target = target; + context.m_target = program->getTargetReq(); context.m_options = options; + context.m_targetProgram = program; context.processModule(module); } diff --git a/source/slang/slang-ir-byte-address-legalize.h b/source/slang/slang-ir-byte-address-legalize.h index c01c0c34d..996a93c73 100644 --- a/source/slang/slang-ir-byte-address-legalize.h +++ b/source/slang/slang-ir-byte-address-legalize.h @@ -4,7 +4,7 @@ namespace Slang { class Session; -class TargetRequest; +class TargetProgram; struct IRModule; struct ByteAddressBufferLegalizationOptions @@ -22,7 +22,7 @@ struct ByteAddressBufferLegalizationOptions /// void legalizeByteAddressBufferOps( Session* session, - TargetRequest* target, + TargetProgram* target, IRModule* module, ByteAddressBufferLegalizationOptions const& options); } diff --git a/source/slang/slang-ir-dll-import.cpp b/source/slang/slang-ir-dll-import.cpp index fbb473ea2..6855e262c 100644 --- a/source/slang/slang-ir-dll-import.cpp +++ b/source/slang/slang-ir-dll-import.cpp @@ -13,7 +13,7 @@ struct DllImportContext { IRModule* module; DiagnosticSink* diagnosticSink; - TargetRequest* targetReq; + TargetProgram* targetProgram; IRFunc* loadDllFunc = nullptr; IRFunc* loadFuncPtrFunc = nullptr; @@ -91,7 +91,7 @@ struct DllImportContext for (auto param : func->getParams()) { IRSizeAndAlignment sizeAndAlignment; - getNaturalSizeAndAlignment(targetReq, param->getDataType(), &sizeAndAlignment); + getNaturalSizeAndAlignment(targetProgram->getOptionSet(), param->getDataType(), &sizeAndAlignment); result += (uint32_t)align(sizeAndAlignment.size, 4); } return result; @@ -188,11 +188,11 @@ struct DllImportContext } }; -void generateDllImportFuncs(TargetRequest* targetReq, IRModule* module, DiagnosticSink* sink) +void generateDllImportFuncs(TargetProgram* targetProgram, IRModule* module, DiagnosticSink* sink) { DllImportContext context; context.module = module; - context.targetReq = targetReq; + context.targetProgram = targetProgram; context.diagnosticSink = sink; return context.processModule(); } diff --git a/source/slang/slang-ir-dll-import.h b/source/slang/slang-ir-dll-import.h index 8ea97527b..dd8e5dc44 100644 --- a/source/slang/slang-ir-dll-import.h +++ b/source/slang/slang-ir-dll-import.h @@ -5,7 +5,7 @@ namespace Slang { struct IRModule; class DiagnosticSink; - class TargetRequest; + class TargetProgram; /// Generate implementations for functions marked as [DllImport]. - void generateDllImportFuncs(TargetRequest* targetReq, IRModule* module, DiagnosticSink* sink); + void generateDllImportFuncs(TargetProgram* targetReq, IRModule* module, DiagnosticSink* sink); } diff --git a/source/slang/slang-ir-extract-value-from-type.cpp b/source/slang/slang-ir-extract-value-from-type.cpp index fa8c6e441..8db4bb7ef 100644 --- a/source/slang/slang-ir-extract-value-from-type.cpp +++ b/source/slang/slang-ir-extract-value-from-type.cpp @@ -16,7 +16,7 @@ struct FindLeafValueResult }; FindLeafValueResult findLeafValueAtOffset( - TargetRequest* targetReq, + TargetProgram* targetProgram, IRBuilder& builder, IRType* dataType, IRSizeAndAlignment& layout, @@ -42,8 +42,8 @@ FindLeafValueResult findLeafValueAtOffset( { IRIntegerValue fieldOffset = 0; IRSizeAndAlignment fieldLayout; - CHECK(getNaturalSizeAndAlignment(targetReq, field->getFieldType(), &fieldLayout)); - CHECK(getNaturalOffset(targetReq, field, &fieldOffset)); + CHECK(getNaturalSizeAndAlignment(targetProgram->getOptionSet(), field->getFieldType(), &fieldLayout)); + CHECK(getNaturalOffset(targetProgram->getOptionSet(), field, &fieldOffset)); if (fieldOffset + fieldLayout.size > offset) { if (fieldOffset > offset) @@ -62,7 +62,7 @@ FindLeafValueResult findLeafValueAtOffset( auto fieldValue = builder.emitFieldExtract(field->getFieldType(), src, field->getKey()); return findLeafValueAtOffset( - targetReq, + targetProgram, builder, field->getFieldType(), fieldLayout, @@ -81,7 +81,7 @@ FindLeafValueResult findLeafValueAtOffset( auto arrayType = as<IRArrayType>(dataType); auto elementType = arrayType->getElementType(); IRSizeAndAlignment elementLayout; - CHECK(getNaturalSizeAndAlignment(targetReq, elementType, &elementLayout)); + CHECK(getNaturalSizeAndAlignment(targetProgram->getOptionSet(), elementType, &elementLayout)); if (elementLayout.getStride() == 0) { result.leafValue = builder.getIntValue(builder.getUIntType(), 0); @@ -93,7 +93,7 @@ FindLeafValueResult findLeafValueAtOffset( auto elementValue = builder.emitElementExtract( elementType, src, builder.getIntValue(builder.getUIntType(), index)); return findLeafValueAtOffset( - targetReq, + targetProgram, builder, elementType, elementLayout, @@ -106,13 +106,13 @@ FindLeafValueResult findLeafValueAtOffset( auto vectorType = as<IRVectorType>(dataType); auto elementType = vectorType->getElementType(); IRSizeAndAlignment elementLayout; - CHECK(getNaturalSizeAndAlignment(targetReq, elementType, &elementLayout)); + CHECK(getNaturalSizeAndAlignment(targetProgram->getOptionSet(), elementType, &elementLayout)); uint32_t index = elementLayout.getStride() == 0 ? 0 : (uint32_t)(offset / elementLayout.getStride()); auto elementValue = builder.emitElementExtract( elementType, src, builder.getIntValue(builder.getUIntType(), index)); return findLeafValueAtOffset( - targetReq, + targetProgram, builder, elementType, elementLayout, @@ -129,14 +129,14 @@ FindLeafValueResult findLeafValueAtOffset( auto columnCount = as<IRIntLit>(matrixType->getColumnCount())->value.intVal; auto rowType = builder.getVectorType(elementType, matrixType->getColumnCount()); IRSizeAndAlignment rowLayout; - CHECK(getNaturalSizeAndAlignment(targetReq, rowType, &rowLayout)); + CHECK(getNaturalSizeAndAlignment(targetProgram->getOptionSet(), rowType, &rowLayout)); uint32_t rowIndex = rowLayout.getStride() == 0 ? 0 : (uint32_t)(offset / (columnCount * rowLayout.getStride())); auto rowValue = builder.emitElementExtract( rowType, src, builder.getIntValue(builder.getUIntType(), rowIndex)); return findLeafValueAtOffset( - targetReq, + targetProgram, builder, rowType, rowLayout, @@ -157,13 +157,13 @@ FindLeafValueResult findLeafValueAtOffset( IRInst* extractByteAtOffset( IRBuilder& builder, - TargetRequest* targetReq, + TargetProgram* targetProgram, IRType* dataType, IRSizeAndAlignment& layout, IRInst* src, uint32_t offset) { - auto leaf = findLeafValueAtOffset(targetReq, builder, dataType, layout, src, offset); + auto leaf = findLeafValueAtOffset(targetProgram, builder, dataType, layout, src, offset); IRType* uintType = nullptr; if (leaf.valueSize <= 4) { @@ -188,7 +188,7 @@ IRInst* extractByteAtOffset( IRInst* extractMultiByteValueAtOffset( IRBuilder& builder, - TargetRequest* targetReq, + TargetProgram* targetProgram, IRType* dataType, IRSizeAndAlignment& layout, IRInst* src, @@ -196,9 +196,9 @@ IRInst* extractMultiByteValueAtOffset( uint32_t offset) { if (size == 1) - return extractByteAtOffset(builder, targetReq, dataType, layout, src, offset); + return extractByteAtOffset(builder, targetProgram, dataType, layout, src, offset); - auto leaf = findLeafValueAtOffset(targetReq, builder, dataType, layout, src, offset); + auto leaf = findLeafValueAtOffset(targetProgram, builder, dataType, layout, src, offset); auto resultValue = leaf.leafValue; IRType* uintType = nullptr; if (leaf.valueSize <= 4) @@ -246,9 +246,9 @@ IRInst* extractMultiByteValueAtOffset( // The requested value crosses the boundaries of different fields. // We need to extract first and second half separately, and combine them together. auto firstHalf = extractMultiByteValueAtOffset( - builder, targetReq, dataType, layout, src, size / 2, offset); + builder, targetProgram, dataType, layout, src, size / 2, offset); auto secondHalf = extractMultiByteValueAtOffset( - builder, targetReq, dataType, layout, src, size / 2, offset + size / 2); + builder, targetProgram, dataType, layout, src, size / 2, offset + size / 2); uint32_t shift = (size / 2) * 8; resultValue = builder.emitAdd( builder.getUIntType(), @@ -262,17 +262,17 @@ IRInst* extractMultiByteValueAtOffset( } IRInst* extractValueAtOffset( - IRBuilder& builder, TargetRequest* targetReq, IRInst* src, uint32_t offset, uint32_t size) + IRBuilder& builder, TargetProgram* targetProgram, IRInst* src, uint32_t offset, uint32_t size) { auto dataType = src->getDataType(); IRSizeAndAlignment typeLayout; - SLANG_RETURN_NULL_ON_FAIL(getNaturalSizeAndAlignment(targetReq, dataType, &typeLayout)); + SLANG_RETURN_NULL_ON_FAIL(getNaturalSizeAndAlignment(targetProgram->getOptionSet(), dataType, &typeLayout)); if (offset + size > typeLayout.size) { return builder.getIntValue(builder.getIntType(), 0); } return extractMultiByteValueAtOffset( - builder, targetReq, dataType, typeLayout, src, size, offset); + builder, targetProgram, dataType, typeLayout, src, size, offset); } } // namespace Slang diff --git a/source/slang/slang-ir-extract-value-from-type.h b/source/slang/slang-ir-extract-value-from-type.h index de39ee545..c4419f2a7 100644 --- a/source/slang/slang-ir-extract-value-from-type.h +++ b/source/slang/slang-ir-extract-value-from-type.h @@ -11,6 +11,6 @@ namespace Slang // starting at `offset` in `src`. `src` must be a value of `struct`, array, vector or basic type. // `size` can be either 1, 2 or 4. The resulting `IRInst` value will have an `uint` type. IRInst* extractValueAtOffset( - IRBuilder& builder, TargetRequest* targetReq, IRInst* src, uint32_t offset, uint32_t size); + IRBuilder& builder, TargetProgram* targetReq, IRInst* src, uint32_t offset, uint32_t size); } diff --git a/source/slang/slang-ir-generics-lowering-context.cpp b/source/slang/slang-ir-generics-lowering-context.cpp index 212e16483..a7f75d7be 100644 --- a/source/slang/slang-ir-generics-lowering-context.cpp +++ b/source/slang/slang-ir-generics-lowering-context.cpp @@ -66,7 +66,7 @@ namespace Slang // For now the only type info we encapsualte is type size. IRSizeAndAlignment sizeAndAlignment; - getNaturalSizeAndAlignment(targetReq, (IRType*)typeInst, &sizeAndAlignment); + getNaturalSizeAndAlignment(targetProgram->getOptionSet(), (IRType*)typeInst, &sizeAndAlignment); builder->addRTTITypeSizeDecoration(result, sizeAndAlignment.size); // Give a name to the rtti object. @@ -235,7 +235,7 @@ namespace Slang // value must be stored out-of-line. // IRSizeAndAlignment sizeAndAlignment; - Result result = getNaturalSizeAndAlignment(targetReq, concreteType, &sizeAndAlignment); + Result result = getNaturalSizeAndAlignment(targetProgram->getOptionSet(), concreteType, &sizeAndAlignment); if(SLANG_FAILED(result) || (sizeAndAlignment.size > anyValueSize)) { // If the value must be stored out-of-line, we construct @@ -386,7 +386,7 @@ namespace Slang if (outLimit) *outLimit = anyValueSize; IRSizeAndAlignment sizeAndAlignment; - Result result = getNaturalSizeAndAlignment(targetReq, concreteType, &sizeAndAlignment); + Result result = getNaturalSizeAndAlignment(targetProgram->getOptionSet(), concreteType, &sizeAndAlignment); if (outTypeSize) *outTypeSize = sizeAndAlignment.size; if(SLANG_FAILED(result) || (sizeAndAlignment.size > anyValueSize)) diff --git a/source/slang/slang-ir-generics-lowering-context.h b/source/slang/slang-ir-generics-lowering-context.h index 509df6a33..3f0e09bd2 100644 --- a/source/slang/slang-ir-generics-lowering-context.h +++ b/source/slang/slang-ir-generics-lowering-context.h @@ -22,7 +22,7 @@ namespace Slang // we are processing. IRModule* module; - TargetRequest* targetReq; + TargetProgram* targetProgram; DiagnosticSink* sink; diff --git a/source/slang/slang-ir-glsl-legalize.cpp b/source/slang/slang-ir-glsl-legalize.cpp index 0f9e88d20..ca9367ea0 100644 --- a/source/slang/slang-ir-glsl-legalize.cpp +++ b/source/slang/slang-ir-glsl-legalize.cpp @@ -2693,7 +2693,7 @@ void legalizeEntryPointParameterForGLSL( bool shouldUseOriginalEntryPointName(CodeGenContext* codeGenContext) { - if (auto hlslOptions = codeGenContext->getTargetReq()->getHLSLToVulkanLayoutOptions()) + if (auto hlslOptions = codeGenContext->getTargetProgram()->getHLSLToVulkanLayoutOptions()) { if (hlslOptions->getUseOriginalEntryPointName()) { diff --git a/source/slang/slang-ir-layout.cpp b/source/slang/slang-ir-layout.cpp index 7c34cea8d..313761d2c 100644 --- a/source/slang/slang-ir-layout.cpp +++ b/source/slang/slang-ir-layout.cpp @@ -51,7 +51,7 @@ namespace Slang { static Result _calcArraySizeAndAlignment( - TargetRequest* target, + CompilerOptionSet& optionSet, IRTypeLayoutRules* rules, IRType* elementType, IRInst* elementCountInst, @@ -69,7 +69,7 @@ static Result _calcArraySizeAndAlignment( } IRSizeAndAlignment elementTypeLayout; - SLANG_RETURN_ON_FAIL(getSizeAndAlignment(target, rules, elementType, &elementTypeLayout)); + SLANG_RETURN_ON_FAIL(getSizeAndAlignment(optionSet, rules, elementType, &elementTypeLayout)); elementTypeLayout = rules->alignCompositeElement(elementTypeLayout); *outSizeAndAlignment = IRSizeAndAlignment( @@ -85,13 +85,13 @@ IRIntegerValue getIntegerValueFromInst(IRInst* inst) } static Result _calcSizeAndAlignment( - TargetRequest* target, + CompilerOptionSet& optionSet, IRTypeLayoutRules* rules, IRType* type, IRSizeAndAlignment* outSizeAndAlignment) { int kPointerSize = 8; - switch (target->getTarget()) + switch (optionSet.getTarget()) { case CodeGenTarget::HostCPPSource: case CodeGenTarget::HostHostCallable: @@ -161,7 +161,7 @@ case kIROp_##TYPE##Type: \ SLANG_ASSERT(!seenFinalUnsizedArrayField); IRSizeAndAlignment fieldTypeLayout; - SLANG_RETURN_ON_FAIL(getSizeAndAlignment(target, rules, field->getFieldType(), &fieldTypeLayout)); + SLANG_RETURN_ON_FAIL(getSizeAndAlignment(optionSet, rules, field->getFieldType(), &fieldTypeLayout)); seenFinalUnsizedArrayField = fieldTypeLayout.size == IRSizeAndAlignment::kIndeterminateSize; structLayout.size = align(offset, fieldTypeLayout.alignment); @@ -202,7 +202,7 @@ case kIROp_##TYPE##Type: \ auto arrayType = cast<IRArrayType>(type); return _calcArraySizeAndAlignment( - target, + optionSet, rules , arrayType->getElementType(), arrayType->getElementCount(), @@ -213,7 +213,7 @@ case kIROp_##TYPE##Type: \ case kIROp_UnsizedArrayType: { auto unsizedArrayType = cast<IRUnsizedArrayType>(type); - getSizeAndAlignment(target, rules, unsizedArrayType->getElementType(), outSizeAndAlignment); + getSizeAndAlignment(optionSet, rules, unsizedArrayType->getElementType(), outSizeAndAlignment); outSizeAndAlignment->size = IRSizeAndAlignment::kIndeterminateSize; return SLANG_OK; } @@ -223,7 +223,7 @@ case kIROp_##TYPE##Type: \ { auto vecType = cast<IRVectorType>(type); IRSizeAndAlignment elementTypeLayout; - getSizeAndAlignment(target, rules, vecType->getElementType(), &elementTypeLayout); + getSizeAndAlignment(optionSet, rules, vecType->getElementType(), &elementTypeLayout); *outSizeAndAlignment = rules->getVectorSizeAndAlignment(elementTypeLayout, getIntegerValueFromInst(vecType->getElementCount())); return SLANG_OK; } @@ -245,7 +245,7 @@ case kIROp_##TYPE##Type: \ { auto elementType = tupleType->getOperand(i); IRSizeAndAlignment fieldTypeLayout; - SLANG_RETURN_ON_FAIL(getSizeAndAlignment(target, rules, (IRType*)elementType, &fieldTypeLayout)); + SLANG_RETURN_ON_FAIL(getSizeAndAlignment(optionSet, rules, (IRType*)elementType, &fieldTypeLayout)); resultLayout.size = align(resultLayout.size, fieldTypeLayout.alignment); resultLayout.alignment = std::max(resultLayout.alignment, fieldTypeLayout.alignment); } @@ -283,7 +283,7 @@ case kIROp_##TYPE##Type: \ { auto colVector = builder.getVectorType(matType->getElementType(), matType->getRowCount()); return _calcArraySizeAndAlignment( - target, + optionSet, rules, colVector, matType->getColumnCount(), @@ -293,7 +293,7 @@ case kIROp_##TYPE##Type: \ { auto rowVector = builder.getVectorType(matType->getElementType(), matType->getColumnCount()); return _calcArraySizeAndAlignment( - target, + optionSet, rules, rowVector, matType->getRowCount(), @@ -347,7 +347,7 @@ IRSizeAndAlignmentDecoration* findSizeAndAlignmentDecorationForLayout(IRType* ty return nullptr; } -Result getSizeAndAlignment(TargetRequest* target, IRTypeLayoutRules* rules, IRType* type, IRSizeAndAlignment* outSizeAndAlignment) +Result getSizeAndAlignment(CompilerOptionSet& optionSet, IRTypeLayoutRules* rules, IRType* type, IRSizeAndAlignment* outSizeAndAlignment) { if (auto decor = findSizeAndAlignmentDecorationForLayout(type, rules->ruleName)) { @@ -356,7 +356,7 @@ Result getSizeAndAlignment(TargetRequest* target, IRTypeLayoutRules* rules, IRTy } IRSizeAndAlignment sizeAndAlignment; - SLANG_RETURN_ON_FAIL(_calcSizeAndAlignment(target, rules, type, &sizeAndAlignment)); + SLANG_RETURN_ON_FAIL(_calcSizeAndAlignment(optionSet, rules, type, &sizeAndAlignment)); if (auto module = type->getModule()) { @@ -387,7 +387,7 @@ IROffsetDecoration* findOffsetDecorationForLayout(IRStructField* field, IRTypeLa return nullptr; } -Result getOffset(TargetRequest* target, IRTypeLayoutRules* rules, IRStructField* field, IRIntegerValue* outOffset) +Result getOffset(CompilerOptionSet& optionSet, IRTypeLayoutRules* rules, IRStructField* field, IRIntegerValue* outOffset) { if (auto decor = findOffsetDecorationForLayout(field, rules->ruleName)) { @@ -405,7 +405,7 @@ Result getOffset(TargetRequest* target, IRTypeLayoutRules* rules, IRStructField* return SLANG_FAIL; IRSizeAndAlignment structTypeLayout; - SLANG_RETURN_ON_FAIL(getSizeAndAlignment(target, rules, structType, &structTypeLayout)); + SLANG_RETURN_ON_FAIL(getSizeAndAlignment(optionSet, rules, structType, &structTypeLayout)); if (auto decor = findOffsetDecorationForLayout(field, rules->ruleName)) { @@ -492,15 +492,15 @@ struct Std140LayoutRules : IRTypeLayoutRules } }; -Result getNaturalSizeAndAlignment(TargetRequest* target, IRType* type, IRSizeAndAlignment* outSizeAndAlignment) +Result getNaturalSizeAndAlignment(CompilerOptionSet& optionSet, IRType* type, IRSizeAndAlignment* outSizeAndAlignment) { - return getSizeAndAlignment(target, IRTypeLayoutRules::getNatural(), type, outSizeAndAlignment); + return getSizeAndAlignment(optionSet, IRTypeLayoutRules::getNatural(), type, outSizeAndAlignment); } -Result getNaturalOffset(TargetRequest* target, IRStructField* field, IRIntegerValue* outOffset) +Result getNaturalOffset(CompilerOptionSet& optionSet, IRStructField* field, IRIntegerValue* outOffset) { - return getOffset(target, IRTypeLayoutRules::getNatural(), field, outOffset); + return getOffset(optionSet, IRTypeLayoutRules::getNatural(), field, outOffset); } @@ -508,14 +508,14 @@ Result getNaturalOffset(TargetRequest* target, IRStructField* field, IRIntegerVa // Std430 Layout ////////////////////////// -Result getStd430SizeAndAlignment(TargetRequest* target, IRType* type, IRSizeAndAlignment* outSizeAndAlignment) +Result getStd430SizeAndAlignment(CompilerOptionSet& optionSet, IRType* type, IRSizeAndAlignment* outSizeAndAlignment) { - return getSizeAndAlignment(target, IRTypeLayoutRules::getStd430(), type, outSizeAndAlignment); + return getSizeAndAlignment(optionSet, IRTypeLayoutRules::getStd430(), type, outSizeAndAlignment); } -Result getStd430Offset(TargetRequest* target, IRStructField* field, IRIntegerValue* outOffset) +Result getStd430Offset(CompilerOptionSet& optionSet, IRStructField* field, IRIntegerValue* outOffset) { - return getOffset(target, IRTypeLayoutRules::getStd430(), field, outOffset); + return getOffset(optionSet, IRTypeLayoutRules::getStd430(), field, outOffset); } IRTypeLayoutRules* IRTypeLayoutRules::getStd430() diff --git a/source/slang/slang-ir-layout.h b/source/slang/slang-ir-layout.h index 19360aa20..09da2a8f9 100644 --- a/source/slang/slang-ir-layout.h +++ b/source/slang/slang-ir-layout.h @@ -21,7 +21,7 @@ namespace Slang { -class TargetRequest; +struct CompilerOptionSet; /// Align `value` to the next multiple of `alignment`, which must be a power of two. inline IRIntegerValue align(IRIntegerValue value, int alignment) @@ -67,9 +67,9 @@ public: static IRTypeLayoutRules* get(IRTypeLayoutRuleName name); }; -Result getOffset(TargetRequest* target, IRTypeLayoutRules* rules, IRStructField* field, IRIntegerValue* outOffset); +Result getOffset(CompilerOptionSet& optionSet, IRTypeLayoutRules* rules, IRStructField* field, IRIntegerValue* outOffset); -Result getSizeAndAlignment(TargetRequest* target, IRTypeLayoutRules* rules, IRType* type, IRSizeAndAlignment* outSizeAndAlignment); +Result getSizeAndAlignment(CompilerOptionSet& optionSet, IRTypeLayoutRules* rules, IRType* type, IRSizeAndAlignment* outSizeAndAlignment); /// Compute (if necessary) and return the natural size and alignment of `type`. /// @@ -77,7 +77,7 @@ Result getSizeAndAlignment(TargetRequest* target, IRTypeLayoutRules* rules, IRTy /// general-purpose memory for the current target. In that case the /// type is considered to have no natural layout. /// -Result getNaturalSizeAndAlignment(TargetRequest* target, IRType* type, IRSizeAndAlignment* outSizeAndAlignment); +Result getNaturalSizeAndAlignment(CompilerOptionSet& optionSet, IRType* type, IRSizeAndAlignment* outSizeAndAlignment); /// Compute (if necessary) and return the natural offset of `field` /// @@ -85,7 +85,7 @@ Result getNaturalSizeAndAlignment(TargetRequest* target, IRType* type, IRSizeAnd /// that can be stored in general-purpose memory. In that case, the /// field is considered to have no natural offset. /// -Result getNaturalOffset(TargetRequest* target, IRStructField* field, IRIntegerValue* outOffset); +Result getNaturalOffset(CompilerOptionSet& optionSet, IRStructField* field, IRIntegerValue* outOffset); /// Compute (if necessary) and return the std430 size and alignment of `type`. /// @@ -93,7 +93,7 @@ Result getNaturalOffset(TargetRequest* target, IRStructField* field, IRIntegerVa /// general-purpose memory for the current target. In that case the /// type is considered to have no std430 layout. /// -Result getStd430SizeAndAlignment(TargetRequest* target, IRType* type, IRSizeAndAlignment* outSizeAndAlignment); +Result getStd430SizeAndAlignment(CompilerOptionSet& optionSet, IRType* type, IRSizeAndAlignment* outSizeAndAlignment); /// Compute (if necessary) and return the std430 offset of `field` /// @@ -101,7 +101,7 @@ Result getStd430SizeAndAlignment(TargetRequest* target, IRType* type, IRSizeAndA /// that can be stored in general-purpose memory. In that case, the /// field is considered to have no std430 offset. /// -Result getStd430Offset(TargetRequest* target, IRStructField* field, IRIntegerValue* outOffset); +Result getStd430Offset(CompilerOptionSet& optionSet, IRStructField* field, IRIntegerValue* outOffset); } diff --git a/source/slang/slang-ir-loop-unroll.cpp b/source/slang/slang-ir-loop-unroll.cpp index d998f5e61..753c930a8 100644 --- a/source/slang/slang-ir-loop-unroll.cpp +++ b/source/slang/slang-ir-loop-unroll.cpp @@ -67,7 +67,7 @@ static int _getLoopMaxIterationsToUnroll(IRLoop* loopInst) } static void _foldAndSimplifyLoopIteration( - TargetRequest* targetRequest, + TargetProgram* targetProgram, IRBuilder& builder, List<IRBlock*>& clonedBlocks, IRBlock* firstIterationBreakBlock, @@ -81,7 +81,7 @@ static void _foldAndSimplifyLoopIteration( { for (auto inst : b->getChildren()) { - tryReplaceInstUsesWithSimplifiedValue(targetRequest, builder.getModule(), inst); + tryReplaceInstUsesWithSimplifiedValue(targetProgram, builder.getModule(), inst); } } @@ -89,7 +89,7 @@ static void _foldAndSimplifyLoopIteration( // the phi arguments for next iteration evaluated (args in the new loop inst). for (auto inst : firstIterationBreakBlock->getChildren()) { - tryReplaceInstUsesWithSimplifiedValue(targetRequest, builder.getModule(), inst); + tryReplaceInstUsesWithSimplifiedValue(targetProgram, builder.getModule(), inst); } // Fold conditional branches into unconditional branches if the condition is known. @@ -148,7 +148,7 @@ static void _foldAndSimplifyLoopIteration( // Returns true if we can statically determine that the loop terminated within the iteration limit. // This operation assumes the loop does not have `continue` jumps, i.e. continueBlock == targetBlock. static bool _unrollLoop( - TargetRequest* targetRequest, + TargetProgram* targetProgram, IRModule* module, IRLoop* loopInst, List<IRBlock*>& blocks) @@ -341,7 +341,7 @@ static bool _unrollLoop( // conditional jumps can be folded into unconditional jumps. _foldAndSimplifyLoopIteration( - targetRequest, builder, clonedBlocks, firstIterationBreakBlock, unreachableBlock); + targetProgram, builder, clonedBlocks, firstIterationBreakBlock, unreachableBlock); // Now we have peeled off one iteration from the loop, we check if there are any // branches into next iteration, if not, the loop terminates and we are done. @@ -435,7 +435,7 @@ List<IRLoop*> collectLoopsInFunc(IRGlobalValueWithCode* func, const TFunc& filte } bool unrollLoopsInFunc( - TargetRequest* targetRequest, + TargetProgram* targetProgram, IRModule* module, IRGlobalValueWithCode* func, DiagnosticSink* sink) @@ -453,7 +453,7 @@ bool unrollLoopsInFunc( auto blocks = collectBlocksInRegion(func, loop); auto loopLoc = loop->sourceLoc; - if (!_unrollLoop(targetRequest, module, loop, blocks)) + if (!_unrollLoop(targetProgram, module, loop, blocks)) { if (sink) sink->diagnose(loopLoc, Diagnostics::cannotUnrollLoop); @@ -468,7 +468,7 @@ bool unrollLoopsInFunc( return true; } -bool unrollLoopsInModule(TargetRequest* targetRequest, IRModule* module, DiagnosticSink* sink) +bool unrollLoopsInModule(TargetProgram* target, IRModule* module, DiagnosticSink* sink) { SLANG_PROFILE; @@ -479,7 +479,7 @@ bool unrollLoopsInModule(TargetRequest* targetRequest, IRModule* module, Diagnos if (auto func = as<IRGlobalValueWithCode>(inst)) { - bool result = unrollLoopsInFunc(targetRequest, module, func, sink); + bool result = unrollLoopsInFunc(target, module, func, sink); if (!result) return false; } diff --git a/source/slang/slang-ir-loop-unroll.h b/source/slang/slang-ir-loop-unroll.h index 3b42afe80..d3402bf25 100644 --- a/source/slang/slang-ir-loop-unroll.h +++ b/source/slang/slang-ir-loop-unroll.h @@ -10,12 +10,12 @@ namespace Slang class DiagnosticSink; struct IRModule; struct IRBlock; - class TargetRequest; + class TargetProgram; // Return true if successfull, false if errors occurred. - bool unrollLoopsInFunc(TargetRequest*target, IRModule* module, IRGlobalValueWithCode* func, DiagnosticSink* sink); + bool unrollLoopsInFunc(TargetProgram* target, IRModule* module, IRGlobalValueWithCode* func, DiagnosticSink* sink); - bool unrollLoopsInModule(TargetRequest* target, IRModule* module, DiagnosticSink* sink); + bool unrollLoopsInModule(TargetProgram* target, IRModule* module, DiagnosticSink* sink); // Turn a loop with continue block into a loop with only back jumps and breaks. // Each iteration will be wrapped in a breakable region, where everything before `continue` diff --git a/source/slang/slang-ir-lower-append-consume-structured-buffer.cpp b/source/slang/slang-ir-lower-append-consume-structured-buffer.cpp index 1d4f10bb9..6fb1e3140 100644 --- a/source/slang/slang-ir-lower-append-consume-structured-buffer.cpp +++ b/source/slang/slang-ir-lower-append-consume-structured-buffer.cpp @@ -7,7 +7,7 @@ namespace Slang { - static void lowerStructuredBufferType(TargetRequest* target, IRHLSLStructuredBufferTypeBase* type) + static void lowerStructuredBufferType(TargetProgram* target, IRHLSLStructuredBufferTypeBase* type) { IRBuilder builder(type); builder.setInsertBefore(type); @@ -48,7 +48,7 @@ namespace Slang IRTypeLayout::Builder elementTypeLayoutBuilder(&builder); IRSizeAndAlignment elementSize; - getSizeAndAlignment(target, layoutRules, elementType, &elementSize); + getSizeAndAlignment(target->getOptionSet(), layoutRules, elementType, &elementSize); elementTypeLayoutBuilder.addResourceUsage(LayoutResourceKind::Uniform, LayoutSize((LayoutSize::RawValue)elementSize.getStride())); auto elementTypeLayout = elementTypeLayoutBuilder.build(); @@ -253,7 +253,7 @@ namespace Slang type->replaceUsesWith(structType); } - void lowerAppendConsumeStructuredBuffers(TargetRequest* target, IRModule* module, DiagnosticSink* sink) + void lowerAppendConsumeStructuredBuffers(TargetProgram* target, IRModule* module, DiagnosticSink* sink) { SLANG_UNUSED(sink); for (auto globalInst : module->getGlobalInsts()) diff --git a/source/slang/slang-ir-lower-append-consume-structured-buffer.h b/source/slang/slang-ir-lower-append-consume-structured-buffer.h index 81048724d..5030d08ca 100644 --- a/source/slang/slang-ir-lower-append-consume-structured-buffer.h +++ b/source/slang/slang-ir-lower-append-consume-structured-buffer.h @@ -7,11 +7,11 @@ namespace Slang { struct IRModule; class DiagnosticSink; - class TargetRequest; + class TargetProgram; /// For non-hlsl targets, lower append- and consume- structured buffers into `struct` types /// that contains two RWStructuredBuffer typed fields, one to store the elements, and one /// for the atomic buffer. - void lowerAppendConsumeStructuredBuffers(TargetRequest* target, IRModule* module, DiagnosticSink* sink); + void lowerAppendConsumeStructuredBuffers(TargetProgram* target, IRModule* module, DiagnosticSink* sink); } diff --git a/source/slang/slang-ir-lower-bit-cast.cpp b/source/slang/slang-ir-lower-bit-cast.cpp index 79e95f7de..7a9f605d2 100644 --- a/source/slang/slang-ir-lower-bit-cast.cpp +++ b/source/slang/slang-ir-lower-bit-cast.cpp @@ -9,7 +9,7 @@ namespace Slang struct BitCastLoweringContext { - TargetRequest* targetReq; + TargetProgram* targetProgram; IRModule* module; OrderedHashSet<IRInst*> workList; @@ -72,7 +72,7 @@ struct BitCastLoweringContext { IRIntegerValue fieldOffset = 0; SLANG_RELEASE_ASSERT( - getNaturalOffset(targetReq, field, &fieldOffset) == SLANG_OK); + getNaturalOffset(targetProgram->getOptionSet(), field, &fieldOffset) == SLANG_OK); auto fieldType = field->getFieldType(); auto fieldValue = readObject(builder, src, fieldType, (uint32_t)(fieldOffset + offset)); @@ -90,7 +90,7 @@ struct BitCastLoweringContext IRSizeAndAlignment elementLayout; SLANG_RELEASE_ASSERT( getNaturalSizeAndAlignment( - targetReq, arrayType->getElementType(), &elementLayout) == SLANG_OK); + targetProgram->getOptionSet(), arrayType->getElementType(), &elementLayout) == SLANG_OK); for (IRIntegerValue i = 0; i < arrayCount->value.intVal; i++) { elements.add(readObject( @@ -111,7 +111,7 @@ struct BitCastLoweringContext IRSizeAndAlignment elementLayout; SLANG_RELEASE_ASSERT( getNaturalSizeAndAlignment( - targetReq, vectorType->getElementType(), &elementLayout) == SLANG_OK); + targetProgram->getOptionSet(), vectorType->getElementType(), &elementLayout) == SLANG_OK); for (IRIntegerValue i = 0; i < elementCount->value.intVal; i++) { elements.add(readObject( @@ -136,7 +136,7 @@ struct BitCastLoweringContext matrixType->getElementType(), matrixType->getColumnCount()); IRSizeAndAlignment elementLayout; SLANG_RELEASE_ASSERT( - getNaturalSizeAndAlignment(targetReq, elementType, &elementLayout) == SLANG_OK); + getNaturalSizeAndAlignment(targetProgram->getOptionSet(), elementType, &elementLayout) == SLANG_OK); for (IRIntegerValue i = 0; i < elementCount->value.intVal; i++) { elements.add(readObject( @@ -153,7 +153,7 @@ struct BitCastLoweringContext case kIROp_Int16Type: case kIROp_UInt16Type: { - auto object = extractValueAtOffset(builder, targetReq, src, offset, 2); + auto object = extractValueAtOffset(builder, targetProgram, src, offset, 2); return builder.emitBitCast(type, object); } break; @@ -166,7 +166,7 @@ struct BitCastLoweringContext case kIROp_UIntPtrType: #endif { - auto object = extractValueAtOffset(builder, targetReq, src, offset, 4); + auto object = extractValueAtOffset(builder, targetProgram, src, offset, 4); return builder.emitBitCast(type, object); } break; @@ -179,8 +179,8 @@ struct BitCastLoweringContext #endif case kIROp_RawPointerType: { - auto low = extractValueAtOffset(builder, targetReq, src, offset, 4); - auto high = extractValueAtOffset(builder, targetReq, src, offset + 4, 4); + auto low = extractValueAtOffset(builder, targetProgram, src, offset, 4); + auto high = extractValueAtOffset(builder, targetProgram, src, offset + 4, 4); auto combined = builder.emitAdd(builder.getUInt64Type(), low, builder.emitShl( @@ -195,7 +195,7 @@ struct BitCastLoweringContext case kIROp_UInt8Type: case kIROp_Int8Type: { - auto object = extractValueAtOffset(builder, targetReq, src, offset, 1); + auto object = extractValueAtOffset(builder, targetProgram, src, offset, 1); return builder.emitBitCast(type, object); } break; @@ -247,11 +247,11 @@ struct BitCastLoweringContext } }; -void lowerBitCast(TargetRequest* targetReq, IRModule* module) +void lowerBitCast(TargetProgram* targetProgram, IRModule* module) { BitCastLoweringContext context; context.module = module; - context.targetReq = targetReq; + context.targetProgram = targetProgram; context.processModule(); } diff --git a/source/slang/slang-ir-lower-bit-cast.h b/source/slang/slang-ir-lower-bit-cast.h index 4e93dbe4f..cb80d0dab 100644 --- a/source/slang/slang-ir-lower-bit-cast.h +++ b/source/slang/slang-ir-lower-bit-cast.h @@ -8,8 +8,8 @@ namespace Slang { struct IRModule; -class TargetRequest; +class TargetProgram; -void lowerBitCast(TargetRequest* targetReq, IRModule* module); +void lowerBitCast(TargetProgram* targetReq, IRModule* module); } diff --git a/source/slang/slang-ir-lower-buffer-element-type.cpp b/source/slang/slang-ir-lower-buffer-element-type.cpp index 182b101df..5c797ab23 100644 --- a/source/slang/slang-ir-lower-buffer-element-type.cpp +++ b/source/slang/slang-ir-lower-buffer-element-type.cpp @@ -23,9 +23,9 @@ namespace Slang Dictionary<IRType*, LoweredElementTypeInfo> mapLoweredTypeToInfo[(int)IRTypeLayoutRuleName::_Count]; SlangMatrixLayoutMode defaultMatrixLayout = SLANG_MATRIX_LAYOUT_ROW_MAJOR; - TargetRequest* target; + TargetProgram* target; - LoweredElementTypeContext(TargetRequest* target, SlangMatrixLayoutMode inDefaultMatrixLayout) + LoweredElementTypeContext(TargetProgram* target, SlangMatrixLayoutMode inDefaultMatrixLayout) : target(target), defaultMatrixLayout(inDefaultMatrixLayout) {} @@ -230,7 +230,7 @@ namespace Slang { // For spirv, we always want to lower all matrix types, because matrix types // are considered abstract types. - if (!target->shouldEmitSPIRVDirectly()) + if (!target->getOptionSet().shouldEmitSPIRVDirectly()) { // For other targets, we only lower the matrix types if they differ from the default // matrix layout. @@ -257,7 +257,7 @@ namespace Slang auto vectorType = builder.getVectorType(matrixType->getElementType(), isColMajor?matrixType->getRowCount():matrixType->getColumnCount()); IRSizeAndAlignment elementSizeAlignment; - getSizeAndAlignment(target, rules, vectorType, &elementSizeAlignment); + getSizeAndAlignment(target->getOptionSet(), rules, vectorType, &elementSizeAlignment); elementSizeAlignment = rules->alignCompositeElement(elementSizeAlignment); auto arrayType = builder.getArrayType( @@ -279,7 +279,7 @@ namespace Slang // For spirv backend, we always want to lower all array types, even if the element type // comes out the same. This is because different layout rules may have different array // stride requirements. - if (!target->shouldEmitSPIRVDirectly()) + if (!target->getOptionSet().shouldEmitSPIRVDirectly()) { if (!loweredInnerTypeInfo.convertLoweredToOriginal) { @@ -297,7 +297,7 @@ namespace Slang auto structKey = builder.createStructKey(); builder.addNameHintDecoration(structKey, UnownedStringSlice("data")); IRSizeAndAlignment elementSizeAlignment; - getSizeAndAlignment(target, rules, loweredInnerTypeInfo.loweredType, &elementSizeAlignment); + getSizeAndAlignment(target->getOptionSet(), rules, loweredInnerTypeInfo.loweredType, &elementSizeAlignment); elementSizeAlignment = rules->alignCompositeElement(elementSizeAlignment); auto innerArrayType = builder.getArrayType( loweredInnerTypeInfo.loweredType, @@ -326,7 +326,7 @@ namespace Slang // For spirv backend, we always want to lower all array types, even if the element type // comes out the same. This is because different layout rules may have different array // stride requirements. - if (!target->shouldEmitSPIRVDirectly()) + if (!target->getOptionSet().shouldEmitSPIRVDirectly()) { // For non-spirv target, we skip lowering this type if all field types are unchanged. if (isTrivial) @@ -403,9 +403,9 @@ namespace Slang return info; } - if (target->shouldEmitSPIRVDirectly()) + if (target->getOptionSet().shouldEmitSPIRVDirectly()) { - switch (target->getTarget()) + switch (target->getTargetReq()->getTarget()) { case CodeGenTarget::SPIRV: case CodeGenTarget::SPIRVAssembly: @@ -465,7 +465,7 @@ namespace Slang return info; info = getLoweredTypeInfoImpl(type, rules); IRSizeAndAlignment sizeAlignment; - getSizeAndAlignment(target, rules, info.loweredType, &sizeAlignment); + getSizeAndAlignment(target->getOptionSet(), rules, info.loweredType, &sizeAlignment); loweredTypeInfo[(int)rules->ruleName].set(type, info); mapLoweredTypeToInfo[(int)rules->ruleName].set(info.loweredType, info); return info; @@ -801,9 +801,9 @@ namespace Slang } }; - void lowerBufferElementTypeToStorageType(TargetRequest* target, IRModule* module) + void lowerBufferElementTypeToStorageType(TargetProgram* target, IRModule* module) { - SlangMatrixLayoutMode defaultMatrixMode = (SlangMatrixLayoutMode)target->getDefaultMatrixLayoutMode(); + SlangMatrixLayoutMode defaultMatrixMode = (SlangMatrixLayoutMode)target->getOptionSet().getMatrixLayoutMode(); if (defaultMatrixMode == SLANG_MATRIX_LAYOUT_MODE_UNKNOWN) defaultMatrixMode = SLANG_MATRIX_LAYOUT_ROW_MAJOR; LoweredElementTypeContext context(target, defaultMatrixMode); @@ -811,17 +811,17 @@ namespace Slang } - IRTypeLayoutRules* getTypeLayoutRuleForBuffer(TargetRequest* target, IRType* bufferType) + IRTypeLayoutRules* getTypeLayoutRuleForBuffer(TargetProgram* target, IRType* bufferType) { - if (!isKhronosTarget(target)) + if (!isKhronosTarget(target->getTargetReq())) return IRTypeLayoutRules::getNatural(); // If we are just emitting GLSL, we can just use the general layout rule. - if (!target->shouldEmitSPIRVDirectly()) + if (!target->getOptionSet().shouldEmitSPIRVDirectly()) return IRTypeLayoutRules::getNatural(); // If the user specified a scalar buffer layout, then just use that. - if (target->getForceGLSLScalarBufferLayout()) + if (target->getOptionSet().shouldUseScalarLayout()) return IRTypeLayoutRules::getNatural(); // The default behavior is to use std140 for constant buffers and std430 for other buffers. diff --git a/source/slang/slang-ir-lower-buffer-element-type.h b/source/slang/slang-ir-lower-buffer-element-type.h index b96a34c6e..4d0a7eabe 100644 --- a/source/slang/slang-ir-lower-buffer-element-type.h +++ b/source/slang/slang-ir-lower-buffer-element-type.h @@ -4,7 +4,7 @@ namespace Slang { struct IRModule; - class TargetRequest; + class TargetProgram; struct IRTypeLayoutRules; struct IRType; @@ -15,11 +15,11 @@ namespace Slang // This pass needs to take place after type legalization, and before array return type lowering // because it may create functions that returns array typed values. // - void lowerBufferElementTypeToStorageType(TargetRequest* target, IRModule* module); + void lowerBufferElementTypeToStorageType(TargetProgram* target, IRModule* module); // Returns the type layout rules should be used for a buffer resource type. - IRTypeLayoutRules* getTypeLayoutRuleForBuffer(TargetRequest* target, IRType* bufferType); + IRTypeLayoutRules* getTypeLayoutRuleForBuffer(TargetProgram* target, IRType* bufferType); } #endif diff --git a/source/slang/slang-ir-lower-generic-call.cpp b/source/slang/slang-ir-lower-generic-call.cpp index c312d3c88..e67d97a48 100644 --- a/source/slang/slang-ir-lower-generic-call.cpp +++ b/source/slang/slang-ir-lower-generic-call.cpp @@ -243,7 +243,7 @@ namespace Slang // Don't process intrinsic functions. UnownedStringSlice intrinsicDef; if (findTargetIntrinsicDefinition(getResolvedInstForDecorations(loweredFunc), - sharedContext->targetReq->getTargetCaps(), intrinsicDef)) + sharedContext->targetProgram->getTargetReq()->getTargetCaps(), intrinsicDef)) return; // All callees should have already been lowered in lower-generic-functions pass. diff --git a/source/slang/slang-ir-lower-generic-function.cpp b/source/slang/slang-ir-lower-generic-function.cpp index 1e15f4384..47dc6cc79 100644 --- a/source/slang/slang-ir-lower-generic-function.cpp +++ b/source/slang/slang-ir-lower-generic-function.cpp @@ -45,7 +45,7 @@ namespace Slang SLANG_ASSERT(func); // Do not lower intrinsic functions. UnownedStringSlice intrinsicDef; - if (!func->isDefinition() || findTargetIntrinsicDefinition(func, sharedContext->targetReq->getTargetCaps(), intrinsicDef)) + if (!func->isDefinition() || findTargetIntrinsicDefinition(func, sharedContext->targetProgram->getTargetReq()->getTargetCaps(), intrinsicDef)) { sharedContext->loweredGenericFunctions[genericValue] = genericValue; return genericValue; diff --git a/source/slang/slang-ir-lower-generics.cpp b/source/slang/slang-ir-lower-generics.cpp index f3aa2145e..fd8c9257b 100644 --- a/source/slang/slang-ir-lower-generics.cpp +++ b/source/slang/slang-ir-lower-generics.cpp @@ -205,19 +205,19 @@ namespace Slang } void lowerGenerics( - TargetRequest* targetReq, + TargetProgram* targetProgram, IRModule* module, DiagnosticSink* sink) { SLANG_PROFILE; SharedGenericsLoweringContext sharedContext(module); - sharedContext.targetReq = targetReq; + sharedContext.targetProgram = targetProgram; sharedContext.sink = sink; checkTypeConformanceExists(&sharedContext); - inferAnyValueSizeWhereNecessary(targetReq, module); + inferAnyValueSizeWhereNecessary(targetProgram, module); // Replace all `makeExistential` insts with `makeExistentialWithRTTI` // before making any other changes. This is necessary because a parameter of @@ -255,7 +255,7 @@ namespace Slang // real RTTI objects and witness tables. specializeRTTIObjects(&sharedContext, sink); - simplifyIR(sharedContext.targetReq, module, IRSimplificationOptions::getFast()); + simplifyIR(sharedContext.targetProgram, module, IRSimplificationOptions::getFast()); lowerTuples(module, sink); if (sink->getErrorCount() != 0) diff --git a/source/slang/slang-ir-lower-generics.h b/source/slang/slang-ir-lower-generics.h index 3b29219bd..2ec250803 100644 --- a/source/slang/slang-ir-lower-generics.h +++ b/source/slang/slang-ir-lower-generics.h @@ -7,12 +7,12 @@ namespace Slang {
struct IRModule;
class DiagnosticSink;
- class TargetRequest;
+ class TargetProgram;
/// Lower generic and interface-based code to ordinary types and functions using
/// dynamic dispatch mechanisms.
void lowerGenerics(
- TargetRequest* targetReq,
+ TargetProgram* targetReq,
IRModule* module,
DiagnosticSink* sink);
diff --git a/source/slang/slang-ir-lower-l-value-cast.cpp b/source/slang/slang-ir-lower-l-value-cast.cpp index 4548c5156..db0861ca4 100644 --- a/source/slang/slang-ir-lower-l-value-cast.cpp +++ b/source/slang/slang-ir-lower-l-value-cast.cpp @@ -209,24 +209,24 @@ struct LValueCastLoweringContext castInst->removeAndDeallocate(); } - LValueCastLoweringContext(TargetRequest* targetRequest, IRModule* module): - m_targetReq(targetRequest), + LValueCastLoweringContext(TargetProgram* target, IRModule* module): + m_targetProgram(target), m_module(module) { - m_intermediateSourceLanguage = getIntermediateSourceLanguageForTarget(targetRequest); + m_intermediateSourceLanguage = getIntermediateSourceLanguageForTarget(target); } // The intermediate source language used to produce code for the target. // If no intermediate source language is used will be SourceLanguage::Unknown. SourceLanguage m_intermediateSourceLanguage = SourceLanguage::Unknown; - TargetRequest* m_targetReq; + TargetProgram* m_targetProgram; IRModule* m_module; OrderedHashSet<IRInst*> m_workList; }; -void lowerLValueCast(TargetRequest* targetReq, IRModule* module) +void lowerLValueCast(TargetProgram* target, IRModule* module) { - LValueCastLoweringContext context(targetReq, module); + LValueCastLoweringContext context(target, module); context.processModule(); } diff --git a/source/slang/slang-ir-lower-l-value-cast.h b/source/slang/slang-ir-lower-l-value-cast.h index 3d93d1200..ea0daf06b 100644 --- a/source/slang/slang-ir-lower-l-value-cast.h +++ b/source/slang/slang-ir-lower-l-value-cast.h @@ -15,9 +15,9 @@ namespace Slang { struct IRModule; -class TargetRequest; +class TargetProgram; -void lowerLValueCast(TargetRequest* targetReq, IRModule* module); +void lowerLValueCast(TargetProgram* target, IRModule* module); } // namespace Slang diff --git a/source/slang/slang-ir-lower-reinterpret.cpp b/source/slang/slang-ir-lower-reinterpret.cpp index c4d39b635..afc710539 100644 --- a/source/slang/slang-ir-lower-reinterpret.cpp +++ b/source/slang/slang-ir-lower-reinterpret.cpp @@ -10,7 +10,7 @@ namespace Slang struct ReinterpretLoweringContext { - TargetRequest* targetReq; + TargetProgram* targetProgram; DiagnosticSink* sink; IRModule* module; OrderedHashSet<IRInst*> workList; @@ -83,16 +83,16 @@ struct ReinterpretLoweringContext } }; -void lowerReinterpret(TargetRequest* targetReq, IRModule* module, DiagnosticSink* sink) +void lowerReinterpret(TargetProgram* target, IRModule* module, DiagnosticSink* sink) { // Before processing reinterpret insts, ensure that existential types without // user-defined sizes have inferred sizes where possible. // - inferAnyValueSizeWhereNecessary(targetReq, module); + inferAnyValueSizeWhereNecessary(target, module); ReinterpretLoweringContext context; context.module = module; - context.targetReq = targetReq; + context.targetProgram = target; context.sink = sink; context.processModule(); } diff --git a/source/slang/slang-ir-lower-reinterpret.h b/source/slang/slang-ir-lower-reinterpret.h index 623ccb32e..ac49d2492 100644 --- a/source/slang/slang-ir-lower-reinterpret.h +++ b/source/slang/slang-ir-lower-reinterpret.h @@ -8,9 +8,9 @@ namespace Slang { struct IRModule; -class TargetRequest; +class TargetProgram; class DiagnosticSink; -void lowerReinterpret(TargetRequest* targetReq, IRModule* module, DiagnosticSink* sink); +void lowerReinterpret(TargetProgram* targetReq, IRModule* module, DiagnosticSink* sink); } diff --git a/source/slang/slang-ir-lower-size-of.cpp b/source/slang/slang-ir-lower-size-of.cpp index a8b599031..5e7e26824 100644 --- a/source/slang/slang-ir-lower-size-of.cpp +++ b/source/slang/slang-ir-lower-size-of.cpp @@ -55,7 +55,7 @@ struct SizeOfLikeLoweringContext IRSizeAndAlignment sizeAndAlignment; - if (SLANG_FAILED(getNaturalSizeAndAlignment(m_targetReq, typeOperand, &sizeAndAlignment))) + if (SLANG_FAILED(getNaturalSizeAndAlignment(m_targetProgram->getOptionSet(), typeOperand, &sizeAndAlignment))) { // Output a diagnostic failure if(sizeOfLikeInst->getOp() == kIROp_AlignOf) @@ -84,22 +84,22 @@ struct SizeOfLikeLoweringContext sizeOfLikeInst->removeAndDeallocate(); } - SizeOfLikeLoweringContext(TargetRequest* targetReq, IRModule* module, DiagnosticSink* sink): + SizeOfLikeLoweringContext(TargetProgram* targetProgram, IRModule* module, DiagnosticSink* sink): m_module(module), - m_targetReq(targetReq), + m_targetProgram(targetProgram), m_sink(sink) { } - TargetRequest* m_targetReq; + TargetProgram* m_targetProgram; DiagnosticSink* m_sink; IRModule* m_module; OrderedHashSet<IRInst*> m_workList; }; -void lowerSizeOfLike(TargetRequest* targetReq, IRModule* module, DiagnosticSink* sink) +void lowerSizeOfLike(TargetProgram* targetProgram, IRModule* module, DiagnosticSink* sink) { - SizeOfLikeLoweringContext context(targetReq, module, sink); + SizeOfLikeLoweringContext context(targetProgram, module, sink); context.processModule(); } diff --git a/source/slang/slang-ir-lower-size-of.h b/source/slang/slang-ir-lower-size-of.h index 4205aa2f0..90ab40fbd 100644 --- a/source/slang/slang-ir-lower-size-of.h +++ b/source/slang/slang-ir-lower-size-of.h @@ -7,10 +7,10 @@ namespace Slang { struct IRModule; -class TargetRequest; +class TargetProgram; class DiagnosticSink; -void lowerSizeOfLike(TargetRequest* target, IRModule* module, DiagnosticSink* sink); +void lowerSizeOfLike(TargetProgram* target, IRModule* module, DiagnosticSink* sink); } // namespace Slang diff --git a/source/slang/slang-ir-peephole.cpp b/source/slang/slang-ir-peephole.cpp index 39a137490..f9fca35e3 100644 --- a/source/slang/slang-ir-peephole.cpp +++ b/source/slang/slang-ir-peephole.cpp @@ -18,7 +18,7 @@ struct PeepholeContext : InstPassBase bool removeOldInst = true; bool isInGeneric = false; - TargetRequest* targetRequest; + TargetProgram* targetProgram; void maybeRemoveOldInst(IRInst* inst) { @@ -965,13 +965,13 @@ struct PeepholeContext : InstPassBase } case kIROp_GetNaturalStride: { - if (targetRequest) + if (targetProgram) { if (isInGeneric) break; auto type = inst->getOperand(0)->getDataType(); IRSizeAndAlignment sizeAlignment; - getNaturalSizeAndAlignment(targetRequest, type, &sizeAlignment); + getNaturalSizeAndAlignment(targetProgram->getOptionSet(), type, &sizeAlignment); IRBuilder builder(module); builder.setInsertBefore(inst); auto stride = builder.getIntValue(inst->getDataType(), sizeAlignment.getStride()); @@ -1069,24 +1069,24 @@ struct PeepholeContext : InstPassBase } }; -bool peepholeOptimize(TargetRequest* target, IRModule* module) +bool peepholeOptimize(TargetProgram* target, IRModule* module) { PeepholeContext context = PeepholeContext(module); - context.targetRequest = target; + context.targetProgram = target; return context.processModule(); } -bool peepholeOptimize(TargetRequest* target, IRInst* func) +bool peepholeOptimize(TargetProgram* target, IRInst* func) { PeepholeContext context = PeepholeContext(func->getModule()); - context.targetRequest = target; + context.targetProgram = target; return context.processFunc(func); } -bool peepholeOptimizeGlobalScope(TargetRequest* target, IRModule* module) +bool peepholeOptimizeGlobalScope(TargetProgram* target, IRModule* module) { PeepholeContext context = PeepholeContext(module); - context.targetRequest = target; + context.targetProgram = target; bool result = false; for (;;) @@ -1101,13 +1101,13 @@ bool peepholeOptimizeGlobalScope(TargetRequest* target, IRModule* module) return result; } -bool tryReplaceInstUsesWithSimplifiedValue(TargetRequest* target, IRModule* module, IRInst* inst) +bool tryReplaceInstUsesWithSimplifiedValue(TargetProgram* target, IRModule* module, IRInst* inst) { if (inst != tryConstantFoldInst(module, inst)) return true; PeepholeContext context = PeepholeContext(inst->getModule()); - context.targetRequest = target; + context.targetProgram = target; context.removeOldInst = false; context.processInst(inst); return context.changed; diff --git a/source/slang/slang-ir-peephole.h b/source/slang/slang-ir-peephole.h index 28edfbe78..9aa2d6164 100644 --- a/source/slang/slang-ir-peephole.h +++ b/source/slang/slang-ir-peephole.h @@ -6,11 +6,11 @@ namespace Slang struct IRModule; struct IRCall; struct IRInst; - class TargetRequest; + class TargetProgram; /// Apply peephole optimizations. - bool peepholeOptimize(TargetRequest* target, IRModule* module); - bool peepholeOptimize(TargetRequest* target, IRInst* func); - bool peepholeOptimizeGlobalScope(TargetRequest* target, IRModule* module); - bool tryReplaceInstUsesWithSimplifiedValue(TargetRequest* target, IRModule* module, IRInst* inst); + bool peepholeOptimize(TargetProgram* target, IRModule* module); + bool peepholeOptimize(TargetProgram* target, IRInst* func); + bool peepholeOptimizeGlobalScope(TargetProgram* target, IRModule* module); + bool tryReplaceInstUsesWithSimplifiedValue(TargetProgram* target, IRModule* module, IRInst* inst); } diff --git a/source/slang/slang-ir-specialize-dispatch.cpp b/source/slang/slang-ir-specialize-dispatch.cpp index d57e1ed96..9eba0aa4f 100644 --- a/source/slang/slang-ir-specialize-dispatch.cpp +++ b/source/slang/slang-ir-specialize-dispatch.cpp @@ -213,7 +213,7 @@ void ensureWitnessTableSequentialIDs(SharedGenericsLoweringContext* sharedContex { StringBuilder generatedMangledName; - auto linkage = sharedContext->targetReq->getLinkage(); + auto linkage = sharedContext->targetProgram->getTargetReq()->getLinkage(); for (auto inst : sharedContext->module->getGlobalInsts()) { if (inst->getOp() == kIROp_WitnessTable) diff --git a/source/slang/slang-ir-specialize-dynamic-associatedtype-lookup.cpp b/source/slang/slang-ir-specialize-dynamic-associatedtype-lookup.cpp index cbc085da5..5a7fd9412 100644 --- a/source/slang/slang-ir-specialize-dynamic-associatedtype-lookup.cpp +++ b/source/slang/slang-ir-specialize-dynamic-associatedtype-lookup.cpp @@ -157,10 +157,6 @@ struct AssociatedTypeLookupSpecializationContext IRBuilder builder(sharedContext->module); builder.setInsertBefore(inst); auto witnessTableArg = inst->getWitnessTable(); - if (witnessTableArg->getDataType()->getOp() == kIROp_WitnessTableType) - { - witnessTableArg = builder.emitGetSequentialIDInst(witnessTableArg); - } auto callInst = builder.emitCallInst( builder.getWitnessTableIDType(interfaceType), func, witnessTableArg); inst->replaceUsesWith(callInst); diff --git a/source/slang/slang-ir-specialize-function-call.cpp b/source/slang/slang-ir-specialize-function-call.cpp index 01cdf4cd9..7e5d9b59c 100644 --- a/source/slang/slang-ir-specialize-function-call.cpp +++ b/source/slang/slang-ir-specialize-function-call.cpp @@ -79,7 +79,6 @@ struct FunctionParameterSpecializationContext // `specializeFunctionParameters` function. // CodeGenContext* codeGenContext; - TargetRequest* targetRequest; IRModule* module; // The condition on which parameters to specialize. @@ -173,7 +172,7 @@ struct FunctionParameterSpecializationContext if(!func->isDefinition()) return false; UnownedStringSlice def; - if (findTargetIntrinsicDefinition(func, targetRequest->getTargetCaps(), def)) + if (findTargetIntrinsicDefinition(func, codeGenContext->getTargetReq()->getTargetCaps(), def)) return false; // With the basic checks out of the way, there are // two conditions we care about: @@ -891,7 +890,7 @@ struct FunctionParameterSpecializationContext // addCallsToWorkListRec(newFunc); - simplifyFunc(targetRequest, newFunc, IRSimplificationOptions::getFast()); + simplifyFunc(codeGenContext->getTargetProgram(), newFunc, IRSimplificationOptions::getFast()); return newFunc; } @@ -908,7 +907,6 @@ bool specializeFunctionCalls( { FunctionParameterSpecializationContext context; context.codeGenContext = codeGenContext; - context.targetRequest = codeGenContext->getTargetReq(); context.module = module; context.condition = condition; diff --git a/source/slang/slang-ir-specialize-matrix-layout.cpp b/source/slang/slang-ir-specialize-matrix-layout.cpp index 5ce61f4cf..8f6ca1b12 100644 --- a/source/slang/slang-ir-specialize-matrix-layout.cpp +++ b/source/slang/slang-ir-specialize-matrix-layout.cpp @@ -24,12 +24,12 @@ namespace Slang } } - void specializeMatrixLayout(TargetRequest* target, IRModule* module) + void specializeMatrixLayout(TargetProgram* target, IRModule* module) { List<IRMatrixType*> typeWorkList; visitParent(typeWorkList, module->getModuleInst()); - IRIntegerValue defaultLayout = target->getDefaultMatrixLayoutMode(); + IRIntegerValue defaultLayout = target->getOptionSet().getMatrixLayoutMode(); if (defaultLayout == SLANG_MATRIX_LAYOUT_MODE_UNKNOWN) defaultLayout = SLANG_MATRIX_LAYOUT_ROW_MAJOR; diff --git a/source/slang/slang-ir-specialize-matrix-layout.h b/source/slang/slang-ir-specialize-matrix-layout.h index 3074f72cf..b0bde29f0 100644 --- a/source/slang/slang-ir-specialize-matrix-layout.h +++ b/source/slang/slang-ir-specialize-matrix-layout.h @@ -4,12 +4,12 @@ namespace Slang { struct IRModule; - class TargetRequest; + class TargetProgram; // Repalce all matrix types whose layout is not specified with the default layout // of the target request. // - void specializeMatrixLayout(TargetRequest* target, IRModule* module); + void specializeMatrixLayout(TargetProgram* target, IRModule* module); } diff --git a/source/slang/slang-ir-specialize-resources.cpp b/source/slang/slang-ir-specialize-resources.cpp index 4fd87e173..af7f41207 100644 --- a/source/slang/slang-ir-specialize-resources.cpp +++ b/source/slang/slang-ir-specialize-resources.cpp @@ -20,6 +20,7 @@ struct ResourceParameterSpecializationCondition : FunctionCallSpecializeConditio // legal for a given target. TargetRequest* targetRequest = nullptr; + TargetProgram* targetProgram = nullptr; bool doesParamWantSpecialization(IRParam* param, IRInst* arg) { @@ -63,7 +64,7 @@ struct ResourceParameterSpecializationCondition : FunctionCallSpecializeConditio // if( isKhronosTarget(targetRequest) ) { - if (targetRequest->shouldEmitSPIRVDirectly()) + if (targetProgram->getOptionSet().shouldEmitSPIRVDirectly()) return isIllegalSPIRVParameterType(type, isArray); else return isIllegalGLSLParameterType(type); @@ -90,6 +91,7 @@ bool specializeResourceParameters( { bool result = false; ResourceParameterSpecializationCondition condition; + condition.targetProgram = codeGenContext->getTargetProgram(); condition.targetRequest = codeGenContext->getTargetReq(); bool changed = true; while (changed) @@ -1186,7 +1188,7 @@ bool specializeResourceUsage( // and turned into SSA temporaries. Such optimization may enable // the following passes to "see" and specialize more cases. // - simplifyIR(codeGenContext->getTargetReq(), irModule, IRSimplificationOptions::getFast()); + simplifyIR(codeGenContext->getTargetProgram(), irModule, IRSimplificationOptions::getFast()); result |= changed; } if (unspecializableFuncs.getCount() == 0) @@ -1206,7 +1208,7 @@ bool specializeResourceUsage( inlineCall(call); }); } - simplifyIR(codeGenContext->getTargetReq(), irModule, IRSimplificationOptions::getFast()); + simplifyIR(codeGenContext->getTargetProgram(), irModule, IRSimplificationOptions::getFast()); } return result; } diff --git a/source/slang/slang-ir-specialize.cpp b/source/slang/slang-ir-specialize.cpp index 9de574a9b..3320a7d09 100644 --- a/source/slang/slang-ir-specialize.cpp +++ b/source/slang/slang-ir-specialize.cpp @@ -47,17 +47,17 @@ struct SpecializationContext // we are specializing. IRModule* module; DiagnosticSink* sink; - TargetRequest* targetRequest; + TargetProgram* targetProgram; bool changed = false; - SpecializationContext(IRModule* inModule, TargetRequest* target) + SpecializationContext(IRModule* inModule, TargetProgram* target) : workList(*inModule->getContainerPool().getList<IRInst>()) , workListSet(*inModule->getContainerPool().getHashSet<IRInst>()) , cleanInsts(*module->getContainerPool().getHashSet<IRInst>()) , module(inModule) - , targetRequest(target) + , targetProgram(target) { } @@ -1524,7 +1524,7 @@ struct SpecializationContext // addToWorkList(newFunc); - simplifyFunc(targetRequest, newFunc, IRSimplificationOptions::getFast()); + simplifyFunc(targetProgram, newFunc, IRSimplificationOptions::getFast()); return newFunc; } @@ -2243,7 +2243,7 @@ struct SpecializationContext }; bool specializeModule( - TargetRequest* target, + TargetProgram* target, IRModule* module, DiagnosticSink* sink) { @@ -2383,7 +2383,7 @@ IRInst* specializeGenericImpl( // the same thing. if (auto func = as<IRFunc>(specializedVal)) { - simplifyFunc(context->targetRequest, func, IRSimplificationOptions::getFast()); + simplifyFunc(context->targetProgram, func, IRSimplificationOptions::getFast()); } return specializedVal; diff --git a/source/slang/slang-ir-specialize.h b/source/slang/slang-ir-specialize.h index 23d523a43..d95fa229a 100644 --- a/source/slang/slang-ir-specialize.h +++ b/source/slang/slang-ir-specialize.h @@ -5,11 +5,11 @@ namespace Slang { struct IRModule; class DiagnosticSink; -class TargetRequest; +class TargetProgram; /// Specialize generic and interface-based code to use concrete types. bool specializeModule( - TargetRequest* target, + TargetProgram* target, IRModule* module, DiagnosticSink* sink); diff --git a/source/slang/slang-ir-spirv-legalize.cpp b/source/slang/slang-ir-spirv-legalize.cpp index 62829f553..f2979cb79 100644 --- a/source/slang/slang-ir-spirv-legalize.cpp +++ b/source/slang/slang-ir-spirv-legalize.cpp @@ -97,14 +97,14 @@ struct SPIRVLegalizationContext : public SourceEmitterBase if (m_loweredStructuredBufferTypes.tryGetValue(inst, result)) return result; - auto layoutRules = getTypeLayoutRuleForBuffer(m_sharedContext->m_targetRequest, inst); + auto layoutRules = getTypeLayoutRuleForBuffer(m_sharedContext->m_targetProgram, inst); IRBuilder builder(m_sharedContext->m_irModule); builder.setInsertBefore(inst); auto elementType = inst->getElementType(); IRSizeAndAlignment elementSize; - getSizeAndAlignment(m_sharedContext->m_targetRequest, layoutRules, elementType, &elementSize); + getSizeAndAlignment(m_sharedContext->m_targetProgram->getOptionSet(), layoutRules, elementType, &elementSize); elementSize = layoutRules->alignCompositeElement(elementSize); const auto arrayType = builder.getUnsizedArrayType(inst->getElementType(), builder.getIntValue(builder.getIntType(), elementSize.getStride())); @@ -112,7 +112,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase const auto arrayKey = builder.createStructKey(); builder.createStructField(structType, arrayKey, arrayType); IRSizeAndAlignment structSize; - getSizeAndAlignment(m_sharedContext->m_targetRequest, layoutRules, structType, &structSize); + getSizeAndAlignment(m_sharedContext->m_targetProgram->getOptionSet(), layoutRules, structType, &structSize); StringBuilder nameSb; switch (inst->getOp()) @@ -190,9 +190,9 @@ struct SPIRVLegalizationContext : public SourceEmitterBase builder.setInsertBefore(cbParamInst); auto newCbType = builder.getType(cbParamInst->getDataType()->getOp(), structType); cbParamInst->setFullType(newCbType); - auto rules = getTypeLayoutRuleForBuffer(m_sharedContext->m_targetRequest, cbParamInst->getDataType()); + auto rules = getTypeLayoutRuleForBuffer(m_sharedContext->m_targetProgram, cbParamInst->getDataType()); IRSizeAndAlignment sizeAlignment; - getSizeAndAlignment(m_sharedContext->m_targetRequest, rules, structType, &sizeAlignment); + getSizeAndAlignment(m_sharedContext->m_targetProgram->getOptionSet(), rules, structType, &sizeAlignment); traverseUses(cbParamInst, [&](IRUse* use) { builder.setInsertBefore(use->getUser()); @@ -2099,7 +2099,7 @@ void buildEntryPointReferenceGraph(SPIRVEmitSharedContext* context, IRModule* mo visit(workList[i].entryPoint, workList[i].inst); } -void simplifyIRForSpirvLegalization(TargetRequest* target, DiagnosticSink* sink, IRModule* module) +void simplifyIRForSpirvLegalization(TargetProgram* target, DiagnosticSink* sink, IRModule* module) { bool changed = true; const int kMaxIterations = 8; @@ -2147,7 +2147,7 @@ void legalizeIRForSPIRV( { SLANG_UNUSED(entryPoints); legalizeSPIRV(context, module); - simplifyIRForSpirvLegalization(context->m_targetRequest, codeGenContext->getSink(), module); + simplifyIRForSpirvLegalization(context->m_targetProgram, codeGenContext->getSink(), module); buildEntryPointReferenceGraph(context, module); } diff --git a/source/slang/slang-ir-spirv-legalize.h b/source/slang/slang-ir-spirv-legalize.h index c9b75c07f..1064e5aa0 100644 --- a/source/slang/slang-ir-spirv-legalize.h +++ b/source/slang/slang-ir-spirv-legalize.h @@ -17,15 +17,17 @@ struct SPIRVEmitSharedContext { IRModule* m_irModule; TargetRequest* m_targetRequest; + TargetProgram* m_targetProgram; Dictionary<IRTargetIntrinsicDecoration*, RefPtr<SpvSnippet>> m_parsedSpvSnippets; Dictionary<IRInst*, HashSet<IRFunc*>> m_referencingEntryPoints; // The entry-points that directly or transitively reference this global inst. DiagnosticSink* m_sink; const SPIRVCoreGrammarInfo* m_grammarInfo; - SPIRVEmitSharedContext(IRModule* module, TargetRequest* target, DiagnosticSink* sink) + SPIRVEmitSharedContext(IRModule* module, TargetProgram* program, DiagnosticSink* sink) : m_irModule(module), - m_targetRequest(target), + m_targetProgram(program), + m_targetRequest(program->getTargetReq()), m_sink(sink), m_grammarInfo(&module->getSession()->getSPIRVCoreGrammarInfo()) {} diff --git a/source/slang/slang-ir-ssa-simplification.cpp b/source/slang/slang-ir-ssa-simplification.cpp index f20d1295c..77cad9f6c 100644 --- a/source/slang/slang-ir-ssa-simplification.cpp +++ b/source/slang/slang-ir-ssa-simplification.cpp @@ -17,7 +17,7 @@ namespace Slang { // Run a combination of SSA, SCCP, SimplifyCFG, and DeadCodeElimination pass // until no more changes are possible. - void simplifyIR(TargetRequest* target, IRModule* module, IRSimplificationOptions options, DiagnosticSink* sink) + void simplifyIR(TargetProgram* target, IRModule* module, IRSimplificationOptions options, DiagnosticSink* sink) { SLANG_PROFILE; bool changed = true; @@ -68,7 +68,7 @@ namespace Slang } } - void simplifyNonSSAIR(TargetRequest* target, IRModule* module, IRSimplificationOptions options) + void simplifyNonSSAIR(TargetProgram* target, IRModule* module, IRSimplificationOptions options) { bool changed = true; const int kMaxIterations = 8; @@ -90,7 +90,7 @@ namespace Slang } - void simplifyFunc(TargetRequest* target, IRGlobalValueWithCode* func, IRSimplificationOptions options, DiagnosticSink* sink) + void simplifyFunc(TargetProgram* target, IRGlobalValueWithCode* func, IRSimplificationOptions options, DiagnosticSink* sink) { bool changed = true; const int kMaxIterations = 8; diff --git a/source/slang/slang-ir-ssa-simplification.h b/source/slang/slang-ir-ssa-simplification.h index d338bf23d..c15ffc822 100644 --- a/source/slang/slang-ir-ssa-simplification.h +++ b/source/slang/slang-ir-ssa-simplification.h @@ -8,7 +8,7 @@ namespace Slang struct IRModule; struct IRGlobalValueWithCode; class DiagnosticSink; - class TargetRequest; + class TargetProgram; struct IRSimplificationOptions { @@ -29,10 +29,10 @@ namespace Slang // Run a combination of SSA, SCCP, SimplifyCFG, and DeadCodeElimination pass // until no more changes are possible. - void simplifyIR(TargetRequest* target, IRModule* module, IRSimplificationOptions options, DiagnosticSink* sink = nullptr); + void simplifyIR(TargetProgram* target, IRModule* module, IRSimplificationOptions options, DiagnosticSink* sink = nullptr); // Run simplifications on IR that is out of SSA form. - void simplifyNonSSAIR(TargetRequest* target, IRModule* module, IRSimplificationOptions options); + void simplifyNonSSAIR(TargetProgram* target, IRModule* module, IRSimplificationOptions options); - void simplifyFunc(TargetRequest* target, IRGlobalValueWithCode* func, IRSimplificationOptions options, DiagnosticSink* sink = nullptr); + void simplifyFunc(TargetProgram* target, IRGlobalValueWithCode* func, IRSimplificationOptions options, DiagnosticSink* sink = nullptr); } diff --git a/source/slang/slang-ir-string-hash.cpp b/source/slang/slang-ir-string-hash.cpp index b7e37d21e..8074bd149 100644 --- a/source/slang/slang-ir-string-hash.cpp +++ b/source/slang/slang-ir-string-hash.cpp @@ -56,26 +56,19 @@ void addGlobalHashedStringLiterals(const StringSlicePool& pool, IRModule* module const Index slicesCount = slices.getCount(); - // Note: This pass is using the extremely low-level `_allocateInst` operation on `IRModule` - // as an optimization. By allocating the instruction here in an "empty" state and then filling - // its operands in in place, we can avoid allocating space for a temporary `List<IRInst*>` to - // hold the IR string values created in the loop below. - // - // TODO: We should probably either eliminate this micro-optimization and just use a `List<IRInst*>` - // here, *or* we should devise a more first-class system for doing in-place instruction creation - // like that that can be compatible with desirable features like automatic deduplication. - // - IRInst* globalHashedInst = module->_allocateInst(kIROp_GlobalHashedStringLiterals, int(slicesCount)); - builder.addInst(globalHashedInst); - - auto operands = globalHashedInst->getOperands(); - + ShortList<IRInst*> operandInsts; for (Index i = 0; i < slicesCount; ++i) { IRStringLit* stringLit = builder.getStringValue(slices[i]); - operands[i].init(globalHashedInst, stringLit); + operandInsts.add(stringLit); } + IRInst* globalHashedInst = builder.emitIntrinsicInst( + nullptr, + kIROp_GlobalHashedStringLiterals, + UInt(slicesCount), + operandInsts.getArrayView().getBuffer()); + // Mark to keep alive builder.addKeepAliveDecoration(globalHashedInst); } diff --git a/source/slang/slang-ir-validate.cpp b/source/slang/slang-ir-validate.cpp index 5caa8a66e..2868c9929 100644 --- a/source/slang/slang-ir-validate.cpp +++ b/source/slang/slang-ir-validate.cpp @@ -378,7 +378,7 @@ namespace Slang CompileRequestBase* compileRequest, IRModule* module) { - if (!compileRequest->shouldValidateIR) + if (!compileRequest->getLinkage()->m_optionSet.getBoolOption(CompilerOptionName::ValidateIr)) return; auto sink = compileRequest->getSink(); diff --git a/source/slang/slang-lower-to-ir.cpp b/source/slang/slang-lower-to-ir.cpp index 8fef6f535..8531e4029 100644 --- a/source/slang/slang-lower-to-ir.cpp +++ b/source/slang/slang-lower-to-ir.cpp @@ -2342,8 +2342,6 @@ static void addNameHint( String name = getNameForNameHint(context, decl); if(name.getLength() == 0) return; - if (name == "MyBlockName2") - printf("break"); context->irBuilder->addNameHintDecoration(inst, name.getUnownedSlice()); } @@ -10238,7 +10236,7 @@ RefPtr<IRModule> generateIRForTranslationUnit( SharedIRGenContext sharedContextStorage( session, translationUnit->compileRequest->getSink(), - translationUnit->compileRequest->getLinkage()->m_obfuscateCode, + translationUnit->compileRequest->optionSet.shouldObfuscateCode(), translationUnit->getModuleDecl(), translationUnit->compileRequest->getLinkage()); SharedIRGenContext* sharedContext = &sharedContextStorage; @@ -10252,7 +10250,7 @@ RefPtr<IRModule> generateIRForTranslationUnit( IRBuilder* builder = &builderStorage; context->irBuilder = builder; - context->includeDebugInfo = compileRequest->getLinkage()->debugInfoLevel != DebugInfoLevel::None; + context->includeDebugInfo = compileRequest->getLinkage()->m_optionSet.getDebugInfoLevel() != DebugInfoLevel::None; // We need to emit IR for all public/exported symbols // in the translation unit. @@ -10450,7 +10448,7 @@ RefPtr<IRModule> generateIRForTranslationUnit( Linkage* linkage = compileRequest->getLinkage(); - stripOptions.shouldStripNameHints = linkage->m_obfuscateCode; + stripOptions.shouldStripNameHints = linkage->m_optionSet.shouldObfuscateCode(); // If we are generating an obfuscated source map, we don't want to strip locs, // we want to generate *new* locs that can be mapped (via source map) @@ -10474,7 +10472,7 @@ RefPtr<IRModule> generateIRForTranslationUnit( options.keepExportsAlive = true; eliminateDeadCode(module, options); - if (linkage->m_obfuscateCode) + if (linkage->m_optionSet.shouldObfuscateCode()) { // The obfuscated source map is stored on the module obfuscateModuleLocs(module, compileRequest->getSourceManager()); @@ -10494,7 +10492,7 @@ RefPtr<IRModule> generateIRForTranslationUnit( // If we are being asked to dump IR during compilation, // then we can dump the initial IR for the module here. - if(compileRequest->shouldDumpIR) + if(compileRequest->optionSet.shouldDumpIR()) { DiagnosticSinkWriter writer(compileRequest->getSink()); @@ -10525,7 +10523,7 @@ struct SpecializedComponentTypeIRGenContext : ComponentTypeVisitor SharedIRGenContext sharedContextStorage( session, sink, - linkage->m_obfuscateCode, + linkage->m_optionSet.shouldObfuscateCode(), nullptr, linkage ); @@ -10664,7 +10662,7 @@ struct TypeConformanceIRGenContext linkage = typeConformance->getLinkage(); session = linkage->getSessionImpl(); - SharedIRGenContext sharedContextStorage(session, sink, linkage->m_obfuscateCode, nullptr, linkage); + SharedIRGenContext sharedContextStorage(session, sink, linkage->m_optionSet.shouldObfuscateCode(), nullptr, linkage); SharedIRGenContext* sharedContext = &sharedContextStorage; IRGenContext contextStorage(sharedContext, linkage->getASTBuilder()); @@ -11016,7 +11014,7 @@ RefPtr<IRModule> TargetProgram::createIRModuleForLayout(DiagnosticSink* sink) SharedIRGenContext sharedContextStorage( session, sink, - linkage->m_obfuscateCode, + linkage->m_optionSet.shouldObfuscateCode(), nullptr, linkage); auto sharedContext = &sharedContextStorage; @@ -11111,12 +11109,12 @@ RefPtr<IRModule> TargetProgram::createIRModuleForLayout(DiagnosticSink* sink) } // Lets strip and run DCE here - if (linkage->m_obfuscateCode) + if (linkage->m_optionSet.shouldObfuscateCode()) { IRStripOptions stripOptions; - stripOptions.shouldStripNameHints = linkage->m_obfuscateCode; - stripOptions.stripSourceLocs = linkage->m_obfuscateCode; + stripOptions.shouldStripNameHints = true; + stripOptions.stripSourceLocs = true;; stripFrontEndOnlyInstructions(irModule, stripOptions); diff --git a/source/slang/slang-options.cpp b/source/slang/slang-options.cpp index ca8b60d31..8e94b73cc 100644 --- a/source/slang/slang-options.cpp +++ b/source/slang/slang-options.cpp @@ -35,8 +35,8 @@ #include "../core/slang-char-util.h" #include "../core/slang-name-value.h" - #include "../core/slang-command-options-writer.h" +#include "slang-compiler-options.h" #include <assert.h> @@ -45,124 +45,7 @@ namespace Slang { namespace { // anonymous // All of the options are given an unique enum -enum class OptionKind -{ - // General - - MacroDefine, - DepFile, - EntryPointName, - Specialize, - Help, - HelpStyle, - Include, - Language, - MatrixLayoutColumn, - MatrixLayoutRow, - ModuleName, - Output, - Profile, - Stage, - Target, - Version, - WarningsAsErrors, - DisableWarnings, - EnableWarning, - DisableWarning, - DumpWarningDiagnostics, - InputFilesRemain, - EmitIr, - ReportDownstreamTime, - ReportPerfBenchmark, - SkipSPIRVValidation, - - SourceEmbedStyle, - SourceEmbedName, - SourceEmbedLanguage, - - // Target - - Capability, - DefaultImageFormatUnknown, - DisableDynamicDispatch, - DisableSpecialization, - FloatingPointMode, - DebugInformation, - LineDirectiveMode, - Optimization, - Obfuscate, - - VulkanBindShift, - VulkanBindGlobals, - VulkanInvertY, - VulkanUseEntryPointName, - VulkanUseGLLayout, - VulkanEmitReflection, - - GLSLForceScalarLayout, - EnableEffectAnnotations, - - EmitSpirvViaGLSL, - EmitSpirvDirectly, - SPIRVCoreGrammarJSON, - - // Downstream - - CompilerPath, - DefaultDownstreamCompiler, - DownstreamArgs, - PassThrough, - - // Repro - - DumpRepro, - DumpReproOnError, - ExtractRepro, - LoadRepro, - LoadReproDirectory, - ReproFallbackDirectory, - - // Debugging - - DumpAst, - DumpIntermediatePrefix, - DumpIntermediates, - DumpIr, - DumpIrIds, - PreprocessorOutput, - NoCodeGen, - OutputIncludes, - ReproFileSystem, - SerialIr, - SkipCodeGen, - ValidateIr, - VerbosePaths, - VerifyDebugSerialIr, - - // Experimental - - FileSystem, - Heterogeneous, - NoMangle, - AllowGLSL, - - // Internal - - ArchiveType, - CompileStdLib, - Doc, - IrCompression, - LoadStdLib, - ReferenceModule, - SaveStdLib, - SaveStdLibBinSource, - TrackLiveness, - - // Deprecated - ParameterBlocksUseRegisterSpaces, - - CountOf, -}; +typedef CompilerOptionName OptionKind; struct Option { @@ -670,7 +553,7 @@ void initCommandOptions(CommandOptions& options) // We can now check that the whole range is available. If this fails it means there // is an enum in the list that hasn't been setup as an option! - SLANG_ASSERT(options.hasContiguousUserValueRange(CommandOptions::LookupKind::Option, UserValue(0), UserValue(OptionKind::CountOf))); + SLANG_ASSERT(options.hasContiguousUserValueRange(CommandOptions::LookupKind::Option, UserValue(0), UserValue(OptionKind::CountOfParsableOptions))); SLANG_ASSERT(options.hasContiguousUserValueRange(CommandOptions::LookupKind::Category, UserValue(0), UserValue(ValueCategory::CountOf))); } @@ -767,12 +650,9 @@ struct OptionsParser struct RawTarget { CodeGenTarget format = CodeGenTarget::Unknown; - ProfileVersion profileVersion = ProfileVersion::Unknown; SlangTargetFlags targetFlags = kDefaultTargetFlags; int targetID = -1; - FloatingPointMode floatingPointMode = FloatingPointMode::Default; - bool forceGLSLScalarLayout = false; - List<CapabilityName> capabilityAtoms; + CompilerOptionSet optionSet; // State for tracking command-line errors bool conflictingProfilesSet = false; @@ -886,10 +766,6 @@ struct OptionsParser // before the first "proper" entry point is specified. RawEntryPoint m_defaultEntryPoint; - SlangCompileFlags m_flags = 0; - - RefPtr<HLSLToVulkanLayoutOptions> m_hlslToVulkanLayoutOptions; - List<RawTranslationUnit> m_rawTranslationUnits; // If we already have a translation unit for Slang code, then this will give its index. @@ -902,6 +778,12 @@ struct OptionsParser int m_translationUnitCount = 0; int m_currentTranslationUnitIndex = -1; + bool m_hasLoadedRepro = false; + bool m_compileStdLib = false; + slang::CompileStdLibFlags m_compileStdLibFlags; + + SlangArchiveType m_archiveType = SLANG_ARCHIVE_TYPE_RIFF_LZ4; + List<RawOutput> m_rawOutputs; DiagnosticSink m_parseSink; @@ -909,19 +791,6 @@ struct OptionsParser FrontEndCompileRequest* m_frontEndReq = nullptr; - SlangMatrixLayoutMode m_defaultMatrixLayoutMode = SLANG_MATRIX_LAYOUT_MODE_UNKNOWN; - - // The default archive type is zip - SlangArchiveType m_archiveType = SLANG_ARCHIVE_TYPE_ZIP; - - bool m_compileStdLib = false; - slang::CompileStdLibFlags m_compileStdLibFlags = 0; - bool m_hasLoadedRepro = false; - - String m_spirvCoreGrammarJSONPath; - - bool m_allowGLSLInput = false; - CommandLineReader m_reader; CommandOptionsWriter::Style m_helpStyle = CommandOptionsWriter::Style::Text; @@ -1161,26 +1030,26 @@ OptionsParser::RawTarget* OptionsParser::getCurrentTarget() void OptionsParser::setProfileVersion(RawTarget* rawTarget, ProfileVersion profileVersion) { - if (rawTarget->profileVersion != ProfileVersion::Unknown) + if (rawTarget->optionSet.getProfileVersion() != ProfileVersion::Unknown) { rawTarget->redundantProfileSet = true; - if (profileVersion != rawTarget->profileVersion) + if (profileVersion != rawTarget->optionSet.getProfileVersion()) { rawTarget->conflictingProfilesSet = true; } } - rawTarget->profileVersion = profileVersion; + rawTarget->optionSet.setProfileVersion(profileVersion); } void OptionsParser::addCapabilityAtom(RawTarget* rawTarget, CapabilityName atom) { - rawTarget->capabilityAtoms.add(atom); + rawTarget->optionSet.addCapabilityAtom(atom); } void OptionsParser::setFloatingPointMode(RawTarget* rawTarget, FloatingPointMode mode) { - rawTarget->floatingPointMode = mode; + rawTarget->optionSet.set(CompilerOptionName::FloatingPointMode, mode); } /* static */bool OptionsParser::_passThroughRequiresStage(PassThroughMode passThrough) @@ -1294,67 +1163,6 @@ SlangResult OptionsParser::_compileReproDirectory(SlangSession* session, EndToEn return SLANG_OK; } -SlangResult OptionsParser::_overrideDiagnostics(const UnownedStringSlice& identifierList, Severity originalSeverity, Severity overrideSeverity) -{ - List<UnownedStringSlice> slices; - StringUtil::split(identifierList, ',', slices); - - for (const auto& slice : slices) - { - SLANG_RETURN_ON_FAIL(_overrideDiagnostic(slice, originalSeverity, overrideSeverity)); - } - return SLANG_OK; -} - -SlangResult OptionsParser::_overrideDiagnostic(const UnownedStringSlice& identifier, Severity originalSeverity, Severity overrideSeverity) -{ - auto diagnosticsLookup = getDiagnosticsLookup(); - - const DiagnosticInfo* diagnostic = nullptr; - Int diagnosticId = -1; - - // If it starts with a digit we assume it a number - if (identifier.getLength() > 0 && (CharUtil::isDigit(identifier[0]) || identifier[0] == '-')) - { - if (SLANG_FAILED(StringUtil::parseInt(identifier, diagnosticId))) - { - m_sink->diagnose(SourceLoc(), Diagnostics::unknownDiagnosticName, identifier); - return SLANG_FAIL; - } - - // If we use numbers, we don't worry if we can't find a diagnostic - // and silently ignore. This was the previous behavior, and perhaps - // provides a way to safely disable warnings, without worrying about - // the version of the compiler. - diagnostic = diagnosticsLookup->getDiagnosticById(diagnosticId); - } - else - { - diagnostic = diagnosticsLookup->findDiagnosticByName(identifier); - if (!diagnostic) - { - m_sink->diagnose(SourceLoc(), Diagnostics::unknownDiagnosticName, identifier); - return SLANG_FAIL; - } - diagnosticId = diagnostic->id; - } - - // If we are only allowing certain original severities check it's the right type - if (diagnostic && originalSeverity != Severity::Disable && diagnostic->severity != originalSeverity) - { - // Strictly speaking the diagnostic name is known, but it's not the right severity - // to be converted from, so it is an 'unknown name' in the context of severity... - // Or perhaps we want another diagnostic - m_sink->diagnose(SourceLoc(), Diagnostics::unknownDiagnosticName, identifier); - return SLANG_FAIL; - } - - // Override the diagnostic severity in the sink - m_requestImpl->getSink()->overrideDiagnosticSeverity(int(diagnosticId), overrideSeverity, diagnostic); - - return SLANG_OK; -} - SlangResult OptionsParser::_dumpDiagnostics(Severity originalSeverity) { // Get the diagnostics and dump them @@ -1784,20 +1592,28 @@ SlangResult OptionsParser::_parse( int argc, char const* const* argv) { - // Copy some state out of the current request, in case we've been called - // after some other initialization has been performed. - m_flags = m_requestImpl->getFrontEndReq()->compileFlags; - // Set up the args CommandLineArgs args(m_cmdLineContext); + // Converts input args into args in 'args'. // Doing so will allocate some SourceLoc space from the CommandLineContext. args.setArgs(argv, argc); + auto linkage = m_requestImpl->getLinkage(); + + // Before we do anything else lets strip out all of the downstream arguments. + DownstreamArgs downstreamArgs(m_cmdLineContext); + + + SLANG_RETURN_ON_FAIL(downstreamArgs.stripDownstreamArgs(args, 0, m_sink)); + for (auto& entry : downstreamArgs.m_entries) { - auto linkage = m_requestImpl->getLinkage(); - // Before we do anything else lets strip out all of the downstream arguments. - SLANG_RETURN_ON_FAIL(linkage->m_downstreamArgs.stripDownstreamArgs(args, 0, m_sink)); + String serializedArgs = entry.args.serialize(); + CompilerOptionValue v; + v.kind = CompilerOptionValueKind::String; + v.stringValue = entry.name; + v.stringValue2 = serializedArgs; + linkage->m_optionSet.add(CompilerOptionName::DownstreamArgs, v); } m_reader.init(&args, m_sink); @@ -1827,9 +1643,37 @@ SlangResult OptionsParser::_parse( switch (optionKind) { - case OptionKind::NoMangle: m_flags |= SLANG_COMPILE_FLAG_NO_MANGLING; break; - case OptionKind::AllowGLSL: m_allowGLSLInput = true; break; - case OptionKind::EmitIr: m_requestImpl->m_emitIr = true; break; + case OptionKind::NoMangle: + case OptionKind::AllowGLSL: + case OptionKind::EmitIr: + case OptionKind::DumpIntermediates: + case OptionKind::DumpReproOnError: + case OptionKind::ReportDownstreamTime: + case OptionKind::ReportPerfBenchmark: + case OptionKind::SkipSPIRVValidation: + case OptionKind::DisableSpecialization: + case OptionKind::DisableDynamicDispatch: + case OptionKind::TrackLiveness: + case OptionKind::SkipCodeGen: + case OptionKind::ParameterBlocksUseRegisterSpaces: + case OptionKind::ValidateIr: + case OptionKind::DumpIr: + case OptionKind::VulkanInvertY: + case OptionKind::VulkanUseEntryPointName: + case OptionKind::VulkanUseGLLayout: + case OptionKind::VulkanEmitReflection: + case OptionKind::MatrixLayoutRow: + case OptionKind::MatrixLayoutColumn: + case OptionKind::DefaultImageFormatUnknown: + case OptionKind::Obfuscate: + case OptionKind::OutputIncludes: + case OptionKind::PreprocessorOutput: + case OptionKind::DumpAst: + linkage->m_optionSet.set(optionKind, true); break; + break; + case OptionKind::NoCodeGen: + linkage->m_optionSet.set(OptionKind::SkipCodeGen, true); break; + break; case OptionKind::LoadStdLib: { CommandLineArg fileName; @@ -1842,7 +1686,11 @@ SlangResult OptionsParser::_parse( break; } case OptionKind::CompileStdLib: m_compileStdLib = true; break; - case OptionKind::ArchiveType: SLANG_RETURN_ON_FAIL(_expectValue(m_archiveType)); break; + case OptionKind::ArchiveType: + { + SLANG_RETURN_ON_FAIL(_expectValue(m_archiveType)); + break; + } case OptionKind::SaveStdLib: { CommandLineArg fileName; @@ -1871,8 +1719,6 @@ SlangResult OptionsParser::_parse( File::writeAllText(fileName.value, builder); break; } - case OptionKind::NoCodeGen: m_flags |= SLANG_COMPILE_FLAG_NO_CODEGEN; break; - case OptionKind::DumpIntermediates: m_compileRequest->setDumpIntermediates(true); break; case OptionKind::DumpIrIds: { m_frontEndReq->m_irDumpOptions.flags |= IRDumpOptions::Flag::DumpDebugIds; @@ -1882,31 +1728,26 @@ SlangResult OptionsParser::_parse( { CommandLineArg prefix; SLANG_RETURN_ON_FAIL(m_reader.expectArg(prefix)); - m_requestImpl->m_dumpIntermediatePrefix = prefix.value; + linkage->m_optionSet.set(CompilerOptionName::DumpIntermediatePrefix, prefix.value); break; } - case OptionKind::OutputIncludes: m_frontEndReq->outputIncludes = true; break; - case OptionKind::DumpIr: m_frontEndReq->shouldDumpIR = true; break; - case OptionKind::PreprocessorOutput: m_frontEndReq->outputPreprocessor = true; break; - case OptionKind::DumpAst: m_frontEndReq->shouldDumpAST = true; break; case OptionKind::Doc: { // If compiling stdlib is enabled, will write out documentation m_compileStdLibFlags |= slang::CompileStdLibFlag::WriteDocumentation; // Enable writing out documentation on the req - m_frontEndReq->shouldDocument = true; + linkage->m_optionSet.set(CompilerOptionName::Doc, true); break; } case OptionKind::DumpRepro: { CommandLineArg dumpRepro; SLANG_RETURN_ON_FAIL(m_reader.expectArg(dumpRepro)); - m_requestImpl->m_dumpRepro = dumpRepro.value; + linkage->m_optionSet.set(OptionKind::DumpRepro, dumpRepro.value); m_compileRequest->enableReproCapture(); break; } - case OptionKind::DumpReproOnError: m_requestImpl->m_dumpReproOnError = true; break; case OptionKind::ExtractRepro: { CommandLineArg reproName; @@ -1922,21 +1763,6 @@ SlangResult OptionsParser::_parse( } break; } - case OptionKind::ReportDownstreamTime: - { - m_compileRequest->setReportDownstreamTime(true); - break; - } - case OptionKind::ReportPerfBenchmark: - { - m_compileRequest->setReportPerfBenchmark(true); - break; - } - case OptionKind::SkipSPIRVValidation: - { - m_compileRequest->setSkipSPIRVValidation(true); - break; - } case OptionKind::ModuleName: { CommandLineArg moduleName; @@ -1986,64 +1812,50 @@ SlangResult OptionsParser::_parse( } case OptionKind::ReproFileSystem: SLANG_RETURN_ON_FAIL(_parseReproFileSystem(arg)); break; case OptionKind::SerialIr: m_frontEndReq->useSerialIRBottleneck = true; break; - case OptionKind::DisableSpecialization: m_requestImpl->disableSpecialization = true; break; - case OptionKind::DisableDynamicDispatch: m_requestImpl->disableDynamicDispatch = true; break; - case OptionKind::TrackLiveness: m_requestImpl->setTrackLiveness(true); break; - case OptionKind::VerbosePaths: m_requestImpl->getSink()->setFlag(DiagnosticSink::Flag::VerbosePath); break; + case OptionKind::VerbosePaths: + m_requestImpl->getSink()->setFlag(DiagnosticSink::Flag::VerbosePath); break; case OptionKind::DumpWarningDiagnostics: _dumpDiagnostics(Severity::Warning); break; case OptionKind::WarningsAsErrors: { CommandLineArg operand; SLANG_RETURN_ON_FAIL(m_reader.expectArg(operand)); - - if (operand.value == "all") - { - // TODO(JS): - // Perhaps there needs to be a way to disable this selectively. - m_requestImpl->getSink()->setFlag(DiagnosticSink::Flag::TreatWarningsAsErrors); - } - else - { - SLANG_RETURN_ON_FAIL(_overrideDiagnostics(operand.value.getUnownedSlice(), Severity::Warning, Severity::Error)); - } + linkage->m_optionSet.add(OptionKind::WarningsAsErrors, operand.value.getUnownedSlice()); break; } case OptionKind::DisableWarnings: { CommandLineArg operand; SLANG_RETURN_ON_FAIL(m_reader.expectArg(operand)); - SLANG_RETURN_ON_FAIL(_overrideDiagnostics(operand.value.getUnownedSlice(), Severity::Warning, Severity::Disable)); + //SLANG_RETURN_ON_FAIL(_overrideDiagnostics(operand.value.getUnownedSlice(), Severity::Warning, Severity::Disable)); + linkage->m_optionSet.add(OptionKind::DisableWarnings, operand.value.getUnownedSlice()); break; } case OptionKind::DisableWarning: { // 5 because -Wno- auto name = argValue.getUnownedSlice().tail(5); - SLANG_RETURN_ON_FAIL(_overrideDiagnostic(name, Severity::Warning, Severity::Disable)); + linkage->m_optionSet.add(OptionKind::DisableWarning, name); + + //SLANG_RETURN_ON_FAIL(_overrideDiagnostic(name, Severity::Warning, Severity::Disable)); break; } case OptionKind::EnableWarning: { // 2 because -W auto name = argValue.getUnownedSlice().tail(2); + linkage->m_optionSet.add(OptionKind::EnableWarning, name); // Enable the warning - SLANG_RETURN_ON_FAIL(_overrideDiagnostic(name, Severity::Warning, Severity::Warning)); + //SLANG_RETURN_ON_FAIL(_overrideDiagnostic(name, Severity::Warning, Severity::Warning)); break; } case OptionKind::VerifyDebugSerialIr: m_frontEndReq->verifyDebugSerialization = true; break; - case OptionKind::ValidateIr: m_frontEndReq->shouldValidateIR = true; break; - case OptionKind::SkipCodeGen: m_requestImpl->m_shouldSkipCodegen = true; break; - case OptionKind::ParameterBlocksUseRegisterSpaces: - { - getCurrentTarget()->targetFlags |= SLANG_TARGET_FLAG_PARAMETER_BLOCKS_USE_REGISTER_SPACES; - break; - } case OptionKind::IrCompression: { CommandLineArg name; SLANG_RETURN_ON_FAIL(m_reader.expectArg(name)); - - SLANG_RETURN_ON_FAIL(SerialParseUtil::parseCompressionType(name.value.getUnownedSlice(), m_requestImpl->getLinkage()->serialCompressionType)); + SerialCompressionType compressionType; + SLANG_RETURN_ON_FAIL(SerialParseUtil::parseCompressionType(name.value.getUnownedSlice(), compressionType)); + linkage->m_optionSet.set(optionKind, compressionType); break; } case OptionKind::Target: @@ -2078,13 +1890,13 @@ SlangResult OptionsParser::_parse( if (m_reader.hasArg() && m_reader.peekArg().value == toSlice("all")) { m_reader.advance(); - m_hlslToVulkanLayoutOptions->setAllShift(kind, shift); + linkage->m_optionSet.add(CompilerOptionName::VulkanBindShiftAll, (int)kind, (int)shift); } else { Int set; SLANG_RETURN_ON_FAIL(_expectInt(arg, set)); - m_hlslToVulkanLayoutOptions->setShift(kind, set, shift); + linkage->m_optionSet.add(CompilerOptionName::VulkanBindShift, (uint8_t)kind, (int)set, (int)shift); } break; } @@ -2094,32 +1906,7 @@ SlangResult OptionsParser::_parse( Int binding, bindingSet; SLANG_RETURN_ON_FAIL(_expectInt(arg, binding)); SLANG_RETURN_ON_FAIL(_expectInt(arg, bindingSet)); - - m_hlslToVulkanLayoutOptions->setGlobalsBinding(Index(bindingSet), Index(binding)); - break; - } - case OptionKind::VulkanInvertY: - { - // -fvk-invert-y - m_hlslToVulkanLayoutOptions->setInvertY(true); - break; - } - case OptionKind::VulkanUseEntryPointName: - { - // -fvk-use-entrypoint-name - m_hlslToVulkanLayoutOptions->setUseOriginalEntryPointName(true); - break; - } - case OptionKind::VulkanUseGLLayout: - { - // -fvk-use-gl-layout - m_hlslToVulkanLayoutOptions->setUseGLLayout(true); - break; - } - case OptionKind::VulkanEmitReflection: - { - // -fvk-invert-y - m_hlslToVulkanLayoutOptions->setEmitSPIRVReflectionInfo(true); + linkage->m_optionSet.set(OptionKind::VulkanBindGlobals, (int)binding, (int)bindingSet); break; } case OptionKind::Profile: SLANG_RETURN_ON_FAIL(_parseProfile(arg)); break; @@ -2172,7 +1959,7 @@ SlangResult OptionsParser::_parse( } case OptionKind::GLSLForceScalarLayout: { - getCurrentTarget()->forceGLSLScalarLayout = true; + getCurrentTarget()->optionSet.add(CompilerOptionName::GLSLForceScalarLayout, true); break; } case OptionKind::EnableEffectAnnotations: @@ -2327,8 +2114,6 @@ SlangResult OptionsParser::_parse( } break; } - case OptionKind::MatrixLayoutRow: m_defaultMatrixLayoutMode = SlangMatrixLayoutMode(kMatrixLayoutMode_RowMajor); break; - case OptionKind::MatrixLayoutColumn: m_defaultMatrixLayoutMode = SlangMatrixLayoutMode(kMatrixLayoutMode_ColumnMajor); break; case OptionKind::LineDirectiveMode: { SlangLineDirectiveMode value; @@ -2357,8 +2142,6 @@ SlangResult OptionsParser::_parse( break; } case OptionKind::DebugInformation: SLANG_RETURN_ON_FAIL(_parseDebugInformation(arg)); break; - case OptionKind::DefaultImageFormatUnknown: m_requestImpl->useUnknownImageFormatAsDefault = true; break; - case OptionKind::Obfuscate: m_requestImpl->getLinkage()->m_obfuscateCode = true; break; case OptionKind::FileSystem: { typedef TypeTextUtil::FileSystemType FileSystemType; @@ -2401,7 +2184,7 @@ SlangResult OptionsParser::_parse( { CommandLineArg path; SLANG_RETURN_ON_FAIL(m_reader.expectArg(path)); - m_spirvCoreGrammarJSONPath = path.value; + m_session->setSPIRVCoreGrammar(path.value.getBuffer()); } break; @@ -2502,16 +2285,6 @@ SlangResult OptionsParser::_parse( } } - // If there is state set on HLSL to Vulkan layout settings, set on the end to end request - // such can be added when target requests are setup - if (!m_hlslToVulkanLayoutOptions->isReset()) - { - m_requestImpl->setHLSLToVulkanLayoutOptions(m_hlslToVulkanLayoutOptions); - } - - // No longer need to track - m_hlslToVulkanLayoutOptions.setNull(); - if (m_compileStdLib) { SLANG_RETURN_ON_FAIL(m_session->compileStdLib(m_compileStdLibFlags)); @@ -2526,10 +2299,6 @@ SlangResult OptionsParser::_parse( return SLANG_OK; } - m_compileRequest->setCompileFlags(m_flags); - - m_compileRequest->setAllowGLSLInput(m_allowGLSLInput); - // As a compatability feature, if the user didn't list any explicit entry // point names, *and* they are compiling a single translation unit, *and* they // have either specified a stage, or we can assume one from the naming @@ -2785,14 +2554,14 @@ SlangResult OptionsParser::_parse( // then we can try to infer a target from the profile. // if (m_rawTargets.getCount() == 0 - && m_defaultTarget.profileVersion != ProfileVersion::Unknown + && m_defaultTarget.optionSet.getProfileVersion() != ProfileVersion::Unknown && !m_defaultTarget.conflictingProfilesSet) { // Let's see if the chosen profile allows us to infer // the code gen target format that the user probably meant. // CodeGenTarget inferredFormat = CodeGenTarget::Unknown; - auto profileVersion = m_defaultTarget.profileVersion; + auto profileVersion = m_defaultTarget.optionSet.getProfileVersion(); switch (Profile(profileVersion).getFamily()) { default: @@ -2837,22 +2606,24 @@ SlangResult OptionsParser::_parse( // Similar to the case for entry points, if there is a single target, // then we allow some of its options to come from the "default" // target state. + auto defaultTargetFloatingPointMode = m_defaultTarget.optionSet.getEnumOption<FloatingPointMode>(CompilerOptionName::FloatingPointMode); + if (m_rawTargets.getCount() == 1) { - if (m_defaultTarget.profileVersion != ProfileVersion::Unknown) + if (m_defaultTarget.optionSet.getProfileVersion() != ProfileVersion::Unknown) { - setProfileVersion(getCurrentTarget(), m_defaultTarget.profileVersion); + setProfileVersion(getCurrentTarget(), m_defaultTarget.optionSet.getProfileVersion()); } - for (auto atom : m_defaultTarget.capabilityAtoms) + for (auto atom : m_defaultTarget.optionSet.getArray(CompilerOptionName::Capability)) { - addCapabilityAtom(getCurrentTarget(), atom); + addCapabilityAtom(getCurrentTarget(), (CapabilityName)atom.intValue); } getCurrentTarget()->targetFlags |= m_defaultTarget.targetFlags; - if (m_defaultTarget.floatingPointMode != FloatingPointMode::Default) + if (defaultTargetFloatingPointMode != FloatingPointMode::Default) { - setFloatingPointMode(getCurrentTarget(), m_defaultTarget.floatingPointMode); + setFloatingPointMode(getCurrentTarget(), defaultTargetFloatingPointMode); } } else @@ -2861,7 +2632,7 @@ SlangResult OptionsParser::_parse( // specified, but there is != 1 taget, then that state doesn't // apply to anythign and we should give the user an error. // - if (m_defaultTarget.profileVersion != ProfileVersion::Unknown) + if (m_defaultTarget.optionSet.getProfileVersion() != ProfileVersion::Unknown) { if (m_rawTargets.getCount() == 0) { @@ -2889,7 +2660,7 @@ SlangResult OptionsParser::_parse( } } - if (m_defaultTarget.floatingPointMode != FloatingPointMode::Default) + if (defaultTargetFloatingPointMode != FloatingPointMode::Default) { if (m_rawTargets.getCount() == 0) { @@ -2910,7 +2681,7 @@ SlangResult OptionsParser::_parse( } else if (rawTarget.redundantProfileSet) { - m_sink->diagnose(SourceLoc(), Diagnostics::sameProfileSpecifiedMoreThanOnce, rawTarget.profileVersion, rawTarget.format); + m_sink->diagnose(SourceLoc(), Diagnostics::sameProfileSpecifiedMoreThanOnce, rawTarget.optionSet.getProfileVersion(), rawTarget.format); } } @@ -2925,13 +2696,13 @@ SlangResult OptionsParser::_parse( int targetID = m_compileRequest->addCodeGenTarget(SlangCompileTarget(rawTarget.format)); rawTarget.targetID = targetID; - if (rawTarget.profileVersion != ProfileVersion::Unknown) + if (rawTarget.optionSet.getProfileVersion() != ProfileVersion::Unknown) { - m_compileRequest->setTargetProfile(targetID, SlangProfileID(Profile(rawTarget.profileVersion).raw)); + m_compileRequest->setTargetProfile(targetID, SlangProfileID(Profile(rawTarget.optionSet.getProfileVersion()).raw)); } - for (auto atom : rawTarget.capabilityAtoms) + for (auto atom : rawTarget.optionSet.getArray(CompilerOptionName::Capability)) { - m_requestImpl->addTargetCapability(targetID, SlangCapabilityID(atom)); + m_requestImpl->addTargetCapability(targetID, SlangCapabilityID(atom.intValue)); } if (rawTarget.targetFlags) @@ -2939,27 +2710,18 @@ SlangResult OptionsParser::_parse( m_compileRequest->setTargetFlags(targetID, rawTarget.targetFlags); } - if (rawTarget.floatingPointMode != FloatingPointMode::Default) + auto floatingPointMode = rawTarget.optionSet.getEnumOption<FloatingPointMode>(CompilerOptionName::FloatingPointMode); + if (floatingPointMode != FloatingPointMode::Default) { - m_compileRequest->setTargetFloatingPointMode(targetID, SlangFloatingPointMode(rawTarget.floatingPointMode)); + m_compileRequest->setTargetFloatingPointMode(targetID, SlangFloatingPointMode(floatingPointMode)); } - if (rawTarget.forceGLSLScalarLayout) + if (rawTarget.optionSet.shouldUseScalarLayout()) { m_compileRequest->setTargetForceGLSLScalarBufferLayout(targetID, true); } } - if (m_defaultMatrixLayoutMode != SLANG_MATRIX_LAYOUT_MODE_UNKNOWN) - { - m_compileRequest->setMatrixLayoutMode(m_defaultMatrixLayoutMode); - } - - if(m_spirvCoreGrammarJSONPath.getLength()) - { - m_session->setSPIRVCoreGrammar(m_spirvCoreGrammarJSONPath.getBuffer()); - } - // Next we need to sort out the output files specified with `-o`, and // figure out which entry point and/or target they apply to. // @@ -3104,7 +2866,7 @@ SlangResult OptionsParser::_parse( } else { - target->addTargetFlags(SLANG_TARGET_FLAG_GENERATE_WHOLE_PROGRAM); + target->getOptionSet().addTargetFlags(SLANG_TARGET_FLAG_GENERATE_WHOLE_PROGRAM); targetInfo->wholeTargetOutputPath = rawOutput.path; } } @@ -3127,6 +2889,12 @@ SlangResult OptionsParser::_parse( } } + // Copy all settings from linkage to targets. + for (auto target : linkage->targets) + target->getOptionSet().inheritFrom(linkage->m_optionSet); + + applySettingsToDiagnosticSink(m_requestImpl->getSink(), m_sink, linkage->m_optionSet); + return (m_sink->getErrorCount() == 0) ? SLANG_OK : SLANG_FAIL; } @@ -3145,14 +2913,11 @@ SlangResult OptionsParser::parse( m_session = session; m_frontEndReq = m_requestImpl->getFrontEndReq(); - m_hlslToVulkanLayoutOptions = new HLSLToVulkanLayoutOptions; - m_cmdOptions = &session->m_commandOptions; + m_cmdLineContext = m_requestImpl->getLinkage()->m_cmdLineContext.get(); DiagnosticSink* requestSink = m_requestImpl->getSink(); - m_cmdLineContext = m_requestImpl->getLinkage()->m_downstreamArgs.getContext(); - // Why create a new DiagnosticSink? // We *don't* want the lexer that comes as default (it's for Slang source!) // We may want to set flags that are different diff --git a/source/slang/slang-parameter-binding.cpp b/source/slang/slang-parameter-binding.cpp index 4ddafa425..c2f8b2d4d 100644 --- a/source/slang/slang-parameter-binding.cpp +++ b/source/slang/slang-parameter-binding.cpp @@ -376,11 +376,12 @@ struct SharedParameterBindingContext SharedParameterBindingContext( LayoutRulesFamilyImpl* defaultLayoutRules, ProgramLayout* programLayout, - TargetRequest* targetReq, + TargetProgram* inTargetProgram, DiagnosticSink* sink) : defaultLayoutRules(defaultLayoutRules) , programLayout(programLayout) - , targetRequest(targetReq) + , targetRequest(inTargetProgram->getTargetReq()) + , targetProgram(inTargetProgram) , m_sink(sink) { } @@ -388,7 +389,7 @@ struct SharedParameterBindingContext DiagnosticSink* m_sink = nullptr; // The program that we are laying out -// Program* program = nullptr; + // Program* program = nullptr; // The target request that is triggering layout // @@ -397,6 +398,8 @@ struct SharedParameterBindingContext // can influence layout decisions. TargetRequest* targetRequest = nullptr; + TargetProgram* targetProgram = nullptr; + LayoutRulesFamilyImpl* defaultLayoutRules; // All shader parameters we've discovered so far, and started to lay out... @@ -422,6 +425,7 @@ struct SharedParameterBindingContext TargetRequest* getTargetRequest() { return targetRequest; } DiagnosticSink* getSink() { return m_sink; } Linkage* getLinkage() { return targetRequest->getLinkage(); } + TargetProgram* getTargetProgram() { return targetProgram; } }; static DiagnosticSink* getSink(SharedParameterBindingContext* shared) @@ -447,6 +451,7 @@ struct ParameterBindingContext EntryPointLayout* entryPointLayout = nullptr; TargetRequest* getTargetRequest() { return shared->getTargetRequest(); } + TargetProgram* getTargetProgram() { return shared->getTargetProgram(); } LayoutRulesFamilyImpl* getRulesFamily() { return layoutContext.getRulesFamily(); } ASTBuilder* getASTBuilder() { return shared->getLinkage()->getASTBuilder(); } @@ -714,7 +719,7 @@ RefPtr<TypeLayout> getTypeLayoutForGlobalShaderParameter( // shader parameter. return createTypeLayoutWith( layoutContext, - rules->getConstantBufferRules(context->getTargetRequest()), + rules->getConstantBufferRules(context->getTargetRequest()->getOptionSet()), type); } @@ -1107,7 +1112,7 @@ static void addExplicitParameterBindings_GLSL( // See if we can infer vulkan binding from HLSL if we have such options set, we know // we can't map - auto hlslToVulkanLayoutOptions = context->getTargetRequest()->getHLSLToVulkanLayoutOptions(); + auto hlslToVulkanLayoutOptions = context->getTargetProgram()->getHLSLToVulkanLayoutOptions(); // If we have the options, but cannot infer bindings, we don't need to go further if (hlslToVulkanLayoutOptions == nullptr || !hlslToVulkanLayoutOptions->canInferBindings()) @@ -1559,7 +1564,7 @@ static RefPtr<TypeLayout> processSimpleEntryPointParameter( // if( isD3DTarget(context->getTargetRequest()) ) { - auto version = context->getTargetRequest()->getTargetProfile().getVersion(); + auto version = context->getTargetProgram()->getOptionSet().getProfileVersion(); if( version <= ProfileVersion::DX_5_0 ) { // We will address the conflict here by claiming the corresponding @@ -2238,7 +2243,7 @@ static RefPtr<TypeLayout> computeEntryPointParameterTypeLayout( // return createTypeLayoutWith( context->layoutContext, - context->getRulesFamily()->getConstantBufferRules(context->getTargetRequest()), + context->getRulesFamily()->getConstantBufferRules(context->getTargetRequest()->getOptionSet()), paramType); } else @@ -2592,7 +2597,7 @@ static ParameterBindingAndKindInfo _allocateConstantBufferBinding( auto usedRangeSet = _getOrCreateUsedRangeSetForSpace(context, space); auto layoutInfo = context->getRulesFamily() - ->getConstantBufferRules(context->getTargetRequest()) + ->getConstantBufferRules(context->getTargetRequest()->getOptionSet()) ->GetObjectLayout(ShaderParameterKind::ConstantBuffer, context->layoutContext.objectLayoutOptions); ParameterBindingAndKindInfo info; @@ -2612,7 +2617,7 @@ static ParameterBindingAndKindInfo _assignConstantBufferBinding( auto usedRangeSet = _getOrCreateUsedRangeSetForSpace(context, space); auto layoutInfo = context->getRulesFamily() - ->getConstantBufferRules(context->getTargetRequest()) + ->getConstantBufferRules(context->getTargetRequest()->getOptionSet()) ->GetObjectLayout(ShaderParameterKind::ConstantBuffer, context->layoutContext.objectLayoutOptions); const Index count = Index(layoutInfo.size.getFiniteValue()); @@ -3555,7 +3560,7 @@ static bool _calcNeedsDefaultSpace(SharedParameterBindingContext& sharedContext) { // If it's uniform, but we have globals binding defined, we don't need a default space for it // as it will go in the global binding specified - if (auto hlslToVulkanOptions = sharedContext.getTargetRequest()->getHLSLToVulkanLayoutOptions()) + if (auto hlslToVulkanOptions = sharedContext.getTargetProgram()->getHLSLToVulkanLayoutOptions()) { if (hlslToVulkanOptions->hasGlobalsBinding()) { @@ -3628,7 +3633,7 @@ static void _appendRange(Index start, LayoutSize size, StringBuilder& ioBuf) static void _maybeApplyHLSLToVulkanShifts( ParameterBindingContext* paramContext, ParameterBindingAndKindInfo& globalConstantBinding, - TargetRequest* targetReq, + TargetProgram* targetProgram, DiagnosticSink* sink) { SLANG_UNUSED(sink); @@ -3636,7 +3641,7 @@ static void _maybeApplyHLSLToVulkanShifts( SharedParameterBindingContext& sharedContext = *paramContext->shared; // We may need to finally do any shifting if we have HLSLToVulkanLayoutOptions - auto vulkanOptions = targetReq->getHLSLToVulkanLayoutOptions(); + auto vulkanOptions = targetProgram->getHLSLToVulkanLayoutOptions(); if (!vulkanOptions) { return; @@ -3773,7 +3778,7 @@ RefPtr<ProgramLayout> generateParameterBindings( SharedParameterBindingContext sharedContext( layoutContext.getRulesFamily(), programLayout, - targetReq, + targetProgram, sink); // Create a sub-context to collect parameters that get @@ -3917,7 +3922,7 @@ RefPtr<ProgramLayout> generateParameterBindings( // If we have a space/binding assigned for use for globals in Vulkan, // we can't use *that* as the default space, so we allocate if - if (auto vulkanOptions = targetReq->getHLSLToVulkanLayoutOptions()) + if (auto vulkanOptions = targetProgram->getHLSLToVulkanLayoutOptions()) { const auto& globalBinding = vulkanOptions->getGlobalsBinding(); @@ -4041,7 +4046,7 @@ RefPtr<ProgramLayout> generateParameterBindings( _completeBindings(&context, program); // We may need to finally do any shifting if we have HLSLToVulkanLayoutOptions - _maybeApplyHLSLToVulkanShifts(&context, globalConstantBufferBinding, targetReq, sink); + _maybeApplyHLSLToVulkanShifts(&context, globalConstantBufferBinding, targetProgram, sink); // Next we need to create a type layout to reflect the information // we have collected, and we will use the `ScopeLayoutBuilder` diff --git a/source/slang/slang-parser.cpp b/source/slang/slang-parser.cpp index 477b43726..e0ffba53c 100644 --- a/source/slang/slang-parser.cpp +++ b/source/slang/slang-parser.cpp @@ -7413,9 +7413,9 @@ namespace Slang ContainerDecl* parentDecl) { ParserOptions options = {}; - options.enableEffectAnnotations = translationUnit->compileRequest->getLinkage()->getEnableEffectAnnotations(); + options.enableEffectAnnotations = translationUnit->compileRequest->optionSet.getBoolOption(CompilerOptionName::EnableEffectAnnotations); options.allowGLSLInput = - translationUnit->compileRequest->getLinkage()->getAllowGLSLInput() || + translationUnit->compileRequest->optionSet.getBoolOption(CompilerOptionName::AllowGLSL) || sourceLanguage == SourceLanguage::GLSL; options.isInLanguageServer = translationUnit->compileRequest->getLinkage()->isInLanguageServer(); diff --git a/source/slang/slang-reflection-api.cpp b/source/slang/slang-reflection-api.cpp index 28b22b833..b9eeccd30 100644 --- a/source/slang/slang-reflection-api.cpp +++ b/source/slang/slang-reflection-api.cpp @@ -2961,6 +2961,12 @@ SLANG_API unsigned int spReflection_GetTypeParameterCount(SlangReflection * refl return (unsigned int) program->specializationParams.getCount(); } +SLANG_API slang::ISession* spReflection_GetSession(SlangReflection* reflection) +{ + auto program = convert(reflection); + return program->getTargetProgram()->getTargetReq()->getLinkage(); +} + SLANG_API SlangReflectionTypeParameter* spReflection_GetTypeParameterByIndex(SlangReflection * reflection, unsigned int index) { auto program = convert(reflection); diff --git a/source/slang/slang-repro.cpp b/source/slang/slang-repro.cpp index a19470ebf..32f8d3289 100644 --- a/source/slang/slang-repro.cpp +++ b/source/slang/slang-repro.cpp @@ -363,19 +363,17 @@ static String _scrubName(const String& in) { RequestState* dst = base[requestState]; - dst->compileFlags = request->getFrontEndReq()->compileFlags; - dst->shouldDumpIntermediates = request->shouldDumpIntermediates; - - dst->debugInfoLevel = linkage->debugInfoLevel; - dst->optimizationLevel = linkage->optimizationLevel; + dst->compileFlags = 0; + dst->shouldDumpIntermediates = linkage->m_optionSet.getBoolOption(CompilerOptionName::DumpIntermediates); + dst->debugInfoLevel = linkage->m_optionSet.getEnumOption<DebugInfoLevel>(CompilerOptionName::DebugInformation); + dst->optimizationLevel = linkage->m_optionSet.getEnumOption<OptimizationLevel>(CompilerOptionName::Optimization); dst->containerFormat = request->m_containerFormat; dst->passThroughMode = request->m_passThrough; + dst->useUnknownImageFormatAsDefault = linkage->m_optionSet.getBoolOption(CompilerOptionName::DefaultImageFormatUnknown);; + dst->obfuscateCode = linkage->m_optionSet.getBoolOption(CompilerOptionName::Obfuscate); - dst->useUnknownImageFormatAsDefault = request->useUnknownImageFormatAsDefault; - dst->obfuscateCode = linkage->m_obfuscateCode; - - dst->defaultMatrixLayoutMode = SlangMatrixLayoutMode(linkage->defaultMatrixLayoutMode); + dst->defaultMatrixLayoutMode = (SlangMatrixLayoutMode)linkage->m_optionSet.getMatrixLayoutMode(); } // Entry points @@ -434,9 +432,9 @@ static String _scrubName(const String& in) { auto& dst = base[dstTargets[i]]; dst.target = srcTargetRequest->getTarget(); - dst.profile = srcTargetRequest->getTargetProfile(); - dst.targetFlags = srcTargetRequest->getTargetFlags(); - dst.floatingPointMode = srcTargetRequest->getFloatingPointMode(); + dst.profile = srcTargetRequest->getOptionSet().getProfile(); + dst.targetFlags = srcTargetRequest->getOptionSet().getTargetFlags(); + dst.floatingPointMode = srcTargetRequest->getOptionSet().getEnumOption<FloatingPointMode>(CompilerOptionName::FloatingPointMode); } // Copy the entry point/target output names @@ -475,21 +473,26 @@ static String _scrubName(const String& in) // Add the search paths { - const auto& srcPaths = linkage->searchDirectories.searchDirectories; - Offset32Array<Offset32Ptr<OffsetString> > dstPaths = inOutContainer.newArray<Offset32Ptr<OffsetString> >(srcPaths.getCount()); + auto srcPaths = linkage->getSearchDirectories(); + Offset32Array<Offset32Ptr<OffsetString> > dstPaths = inOutContainer.newArray<Offset32Ptr<OffsetString> >(srcPaths.searchDirectories.getCount()); // We don't handle parents here - SLANG_ASSERT(linkage->searchDirectories.parent == nullptr); - for (Index i = 0; i < srcPaths.getCount(); ++i) + SLANG_ASSERT(srcPaths.parent == nullptr); + for (Index i = 0; i < srcPaths.searchDirectories.getCount(); ++i) { - const auto srcPath = context.fromString(srcPaths[i].path); + const auto srcPath = context.fromString(srcPaths.searchDirectories[i].path); base[dstPaths[i]] = srcPath; } base[requestState]->searchPaths = dstPaths; } // Add preprocessor definitions - base[requestState]->preprocessorDefinitions = context.calcDefines(linkage->preprocessorDefinitions); + Dictionary<String, String> preprocessorDefines; + for (auto def : linkage->m_optionSet.getArray(CompilerOptionName::MacroDefine)) + { + preprocessorDefines[def.stringValue] = def.stringValue2; + } + base[requestState]->preprocessorDefinitions = context.calcDefines(preprocessorDefines); { const auto& srcTranslationUnits = request->getFrontEndReq()->translationUnits; @@ -915,12 +918,26 @@ struct LoadContext externalRequest->setOutputContainerFormat(SlangContainerFormat(requestState->containerFormat)); externalRequest->setPassThrough(SlangPassThrough(request->m_passThrough)); - request->useUnknownImageFormatAsDefault = requestState->useUnknownImageFormatAsDefault; - linkage->m_obfuscateCode = requestState->obfuscateCode; + linkage->m_optionSet.set(CompilerOptionName::DefaultImageFormatUnknown, requestState->useUnknownImageFormatAsDefault); + linkage->m_optionSet.set(CompilerOptionName::Obfuscate, requestState->obfuscateCode); linkage->setMatrixLayoutMode(requestState->defaultMatrixLayoutMode); } + { + const auto& srcPaths = requestState->searchPaths; + for (Index i = 0; i < srcPaths.getCount(); ++i) + { + linkage->m_optionSet.add(CompilerOptionName::Include, base.asRaw(base.asRaw(srcPaths[i]))->getSlice()); + } + } + Dictionary<String, String> preprocessorDefines; + context.loadDefines(requestState->preprocessorDefinitions, preprocessorDefines); + for (auto def : preprocessorDefines) + { + linkage->m_optionSet.addPreprocessorDefine(def.first, def.second); + } + // Add the target requests { for (Index i = 0; i < requestState->targetRequests.getCount(); ++i) @@ -932,9 +949,9 @@ struct LoadContext auto dstTarget = linkage->targets[index]; SLANG_ASSERT(dstTarget->getTarget() == src.target); - dstTarget->setTargetProfile(src.profile); - dstTarget->addTargetFlags(src.targetFlags); - dstTarget->setFloatingPointMode(src.floatingPointMode); + dstTarget->getOptionSet().setProfile(src.profile); + dstTarget->getOptionSet().addTargetFlags(src.targetFlags); + dstTarget->getOptionSet().set(CompilerOptionName::FloatingPointMode, src.floatingPointMode); // If there is output state (like output filenames) add here if (src.outputStates.getCount()) @@ -960,17 +977,6 @@ struct LoadContext } } - { - const auto& srcPaths = requestState->searchPaths; - auto& dstPaths = linkage->searchDirectories.searchDirectories; - dstPaths.setCount(srcPaths.getCount()); - for (Index i = 0; i < srcPaths.getCount(); ++i) - { - dstPaths[i].path = base.asRaw(base.asRaw(srcPaths[i]))->getSlice(); - } - } - - context.loadDefines(requestState->preprocessorDefinitions, linkage->preprocessorDefinitions); { auto frontEndReq = request->getFrontEndReq(); diff --git a/source/slang/slang-serialize-container.cpp b/source/slang/slang-serialize-container.cpp index 6a75064ab..39b67614d 100644 --- a/source/slang/slang-serialize-container.cpp +++ b/source/slang/slang-serialize-container.cpp @@ -123,9 +123,9 @@ namespace Slang { auto& dstTarget = targetComponent.target; - dstTarget.floatingPointMode = target->getFloatingPointMode(); - dstTarget.profile = target->getTargetProfile(); - dstTarget.flags = target->getTargetFlags(); + dstTarget.floatingPointMode = target->getOptionSet().getFloatingPointMode(); + dstTarget.profile = target->getOptionSet().getProfile(); + dstTarget.flags = target->getOptionSet().getTargetFlags(); dstTarget.codeGenTarget = target->getTarget(); out.targetComponents.add(targetComponent); diff --git a/source/slang/slang-type-layout.cpp b/source/slang/slang-type-layout.cpp index ccd34a966..6b1e2e115 100644 --- a/source/slang/slang-type-layout.cpp +++ b/source/slang/slang-type-layout.cpp @@ -889,14 +889,14 @@ CUDARayTracingLayoutRulesImpl kCUDAHitAttributesParameterLayoutRulesImpl(LayoutR struct GLSLLayoutRulesFamilyImpl : LayoutRulesFamilyImpl { virtual LayoutRulesImpl* getAnyValueRules() override; - virtual LayoutRulesImpl* getConstantBufferRules(TargetRequest* request) override; + virtual LayoutRulesImpl* getConstantBufferRules(CompilerOptionSet& compilerOptions) override; virtual LayoutRulesImpl* getPushConstantBufferRules() override; virtual LayoutRulesImpl* getTextureBufferRules() override; virtual LayoutRulesImpl* getVaryingInputRules() override; virtual LayoutRulesImpl* getVaryingOutputRules() override; virtual LayoutRulesImpl* getSpecializationConstantRules() override; - virtual LayoutRulesImpl* getShaderStorageBufferRules(TargetRequest* request) override; - virtual LayoutRulesImpl* getParameterBlockRules(TargetRequest* request) override; + virtual LayoutRulesImpl* getShaderStorageBufferRules(CompilerOptionSet& compilerOptions) override; + virtual LayoutRulesImpl* getParameterBlockRules(CompilerOptionSet& compilerOptions) override; LayoutRulesImpl* getRayPayloadParameterRules() override; LayoutRulesImpl* getCallablePayloadParameterRules() override; @@ -904,20 +904,20 @@ struct GLSLLayoutRulesFamilyImpl : LayoutRulesFamilyImpl LayoutRulesImpl* getShaderRecordConstantBufferRules() override; - LayoutRulesImpl* getStructuredBufferRules(TargetRequest* request) override; + LayoutRulesImpl* getStructuredBufferRules(CompilerOptionSet& compilerOptions) override; }; struct HLSLLayoutRulesFamilyImpl : LayoutRulesFamilyImpl { virtual LayoutRulesImpl* getAnyValueRules() override; - virtual LayoutRulesImpl* getConstantBufferRules(TargetRequest* request) override; + virtual LayoutRulesImpl* getConstantBufferRules(CompilerOptionSet& compilerOptions) override; virtual LayoutRulesImpl* getPushConstantBufferRules() override; virtual LayoutRulesImpl* getTextureBufferRules() override; virtual LayoutRulesImpl* getVaryingInputRules() override; virtual LayoutRulesImpl* getVaryingOutputRules() override; virtual LayoutRulesImpl* getSpecializationConstantRules() override; - virtual LayoutRulesImpl* getShaderStorageBufferRules(TargetRequest* request) override; - virtual LayoutRulesImpl* getParameterBlockRules(TargetRequest* request) override; + virtual LayoutRulesImpl* getShaderStorageBufferRules(CompilerOptionSet& compilerOptions) override; + virtual LayoutRulesImpl* getParameterBlockRules(CompilerOptionSet& compilerOptions) override; LayoutRulesImpl* getRayPayloadParameterRules() override; LayoutRulesImpl* getCallablePayloadParameterRules() override; @@ -925,47 +925,47 @@ struct HLSLLayoutRulesFamilyImpl : LayoutRulesFamilyImpl LayoutRulesImpl* getShaderRecordConstantBufferRules() override; - LayoutRulesImpl* getStructuredBufferRules(TargetRequest* request) override; + LayoutRulesImpl* getStructuredBufferRules(CompilerOptionSet& compilerOptions) override; }; struct CPULayoutRulesFamilyImpl : LayoutRulesFamilyImpl { virtual LayoutRulesImpl* getAnyValueRules() override; - virtual LayoutRulesImpl* getConstantBufferRules(TargetRequest* request) override; + virtual LayoutRulesImpl* getConstantBufferRules(CompilerOptionSet& compilerOptions) override; virtual LayoutRulesImpl* getPushConstantBufferRules() override; virtual LayoutRulesImpl* getTextureBufferRules() override; virtual LayoutRulesImpl* getVaryingInputRules() override; virtual LayoutRulesImpl* getVaryingOutputRules() override; virtual LayoutRulesImpl* getSpecializationConstantRules() override; - virtual LayoutRulesImpl* getShaderStorageBufferRules(TargetRequest* request) override; - virtual LayoutRulesImpl* getParameterBlockRules(TargetRequest* request) override; + virtual LayoutRulesImpl* getShaderStorageBufferRules(CompilerOptionSet& compilerOptions) override; + virtual LayoutRulesImpl* getParameterBlockRules(CompilerOptionSet& compilerOptions) override; LayoutRulesImpl* getRayPayloadParameterRules() override; LayoutRulesImpl* getCallablePayloadParameterRules() override; LayoutRulesImpl* getHitAttributesParameterRules() override; LayoutRulesImpl* getShaderRecordConstantBufferRules() override; - LayoutRulesImpl* getStructuredBufferRules(TargetRequest* request) override; + LayoutRulesImpl* getStructuredBufferRules(CompilerOptionSet& compilerOptions) override; }; struct CUDALayoutRulesFamilyImpl : LayoutRulesFamilyImpl { virtual LayoutRulesImpl* getAnyValueRules() override; - virtual LayoutRulesImpl* getConstantBufferRules(TargetRequest* request) override; + virtual LayoutRulesImpl* getConstantBufferRules(CompilerOptionSet& compilerOptions) override; virtual LayoutRulesImpl* getPushConstantBufferRules() override; virtual LayoutRulesImpl* getTextureBufferRules() override; virtual LayoutRulesImpl* getVaryingInputRules() override; virtual LayoutRulesImpl* getVaryingOutputRules() override; virtual LayoutRulesImpl* getSpecializationConstantRules() override; - virtual LayoutRulesImpl* getShaderStorageBufferRules(TargetRequest* request) override; - virtual LayoutRulesImpl* getParameterBlockRules(TargetRequest* request) override; + virtual LayoutRulesImpl* getShaderStorageBufferRules(CompilerOptionSet& compilerOptions) override; + virtual LayoutRulesImpl* getParameterBlockRules(CompilerOptionSet& compilerOptions) override; LayoutRulesImpl* getRayPayloadParameterRules() override; LayoutRulesImpl* getCallablePayloadParameterRules() override; LayoutRulesImpl* getHitAttributesParameterRules() override; LayoutRulesImpl* getShaderRecordConstantBufferRules() override; - LayoutRulesImpl* getStructuredBufferRules(TargetRequest* request) override; + LayoutRulesImpl* getStructuredBufferRules(CompilerOptionSet& compilerOptions) override; }; GLSLLayoutRulesFamilyImpl kGLSLLayoutRulesFamilyImpl; @@ -1229,16 +1229,16 @@ LayoutRulesImpl* GLSLLayoutRulesFamilyImpl::getAnyValueRules() return &kGLSLAnyValueLayoutRulesImpl_; } -LayoutRulesImpl* GLSLLayoutRulesFamilyImpl::getConstantBufferRules(TargetRequest* targetReq) +LayoutRulesImpl* GLSLLayoutRulesFamilyImpl::getConstantBufferRules(CompilerOptionSet& compilerOptions) { - if (targetReq->getForceGLSLScalarBufferLayout()) + if (compilerOptions.shouldUseScalarLayout()) return &kScalarLayoutRulesImpl_; return &kStd140LayoutRulesImpl_; } -LayoutRulesImpl* GLSLLayoutRulesFamilyImpl::getParameterBlockRules(TargetRequest* targetReq) +LayoutRulesImpl* GLSLLayoutRulesFamilyImpl::getParameterBlockRules(CompilerOptionSet& compilerOptions) { - if (targetReq->getForceGLSLScalarBufferLayout()) + if (compilerOptions.shouldUseScalarLayout()) return &kScalarLayoutRulesImpl_; return &kStd140LayoutRulesImpl_; } @@ -1273,9 +1273,9 @@ LayoutRulesImpl* GLSLLayoutRulesFamilyImpl::getSpecializationConstantRules() return &kGLSLSpecializationConstantLayoutRulesImpl_; } -LayoutRulesImpl* GLSLLayoutRulesFamilyImpl::getShaderStorageBufferRules(TargetRequest* request) +LayoutRulesImpl* GLSLLayoutRulesFamilyImpl::getShaderStorageBufferRules(CompilerOptionSet& compilerOptions) { - if (request->getForceGLSLScalarBufferLayout()) + if (compilerOptions.shouldUseScalarLayout()) return &kScalarLayoutRulesImpl_; return &kStd430LayoutRulesImpl_; } @@ -1295,9 +1295,9 @@ LayoutRulesImpl* GLSLLayoutRulesFamilyImpl::getHitAttributesParameterRules() return &kGLSLHitAttributesParameterLayoutRulesImpl_; } -LayoutRulesImpl* GLSLLayoutRulesFamilyImpl::getStructuredBufferRules(TargetRequest* targetReq) +LayoutRulesImpl* GLSLLayoutRulesFamilyImpl::getStructuredBufferRules(CompilerOptionSet& options) { - if (targetReq->getForceGLSLScalarBufferLayout()) + if (options.shouldUseScalarLayout()) return &kScalarLayoutRulesImpl_; return &kGLSLStructuredBufferLayoutRulesImpl_; } @@ -1309,12 +1309,12 @@ LayoutRulesImpl* HLSLLayoutRulesFamilyImpl::getAnyValueRules() return &kHLSLAnyValueLayoutRulesImpl_; } -LayoutRulesImpl* HLSLLayoutRulesFamilyImpl::getConstantBufferRules(TargetRequest*) +LayoutRulesImpl* HLSLLayoutRulesFamilyImpl::getConstantBufferRules(CompilerOptionSet&) { return &kHLSLConstantBufferLayoutRulesImpl_; } -LayoutRulesImpl* HLSLLayoutRulesFamilyImpl::getParameterBlockRules(TargetRequest*) +LayoutRulesImpl* HLSLLayoutRulesFamilyImpl::getParameterBlockRules(CompilerOptionSet&) { // TODO: actually pick something appropriate... return &kHLSLConstantBufferLayoutRulesImpl_; @@ -1331,7 +1331,7 @@ LayoutRulesImpl* HLSLLayoutRulesFamilyImpl::getShaderRecordConstantBufferRules() return &kHLSLConstantBufferLayoutRulesImpl_; } -LayoutRulesImpl* HLSLLayoutRulesFamilyImpl::getStructuredBufferRules(TargetRequest*) +LayoutRulesImpl* HLSLLayoutRulesFamilyImpl::getStructuredBufferRules(CompilerOptionSet&) { return &kHLSLStructuredBufferLayoutRulesImpl_; } @@ -1356,7 +1356,7 @@ LayoutRulesImpl* HLSLLayoutRulesFamilyImpl::getSpecializationConstantRules() return nullptr; } -LayoutRulesImpl* HLSLLayoutRulesFamilyImpl::getShaderStorageBufferRules(TargetRequest*) +LayoutRulesImpl* HLSLLayoutRulesFamilyImpl::getShaderStorageBufferRules(CompilerOptionSet&) { return nullptr; } @@ -1383,7 +1383,7 @@ LayoutRulesImpl* CPULayoutRulesFamilyImpl::getAnyValueRules() return &kCPUAnyValueLayoutRulesImpl_; } -LayoutRulesImpl* CPULayoutRulesFamilyImpl::getConstantBufferRules(TargetRequest*) +LayoutRulesImpl* CPULayoutRulesFamilyImpl::getConstantBufferRules(CompilerOptionSet&) { return &kCPULayoutRulesImpl_; } @@ -1410,11 +1410,11 @@ LayoutRulesImpl* CPULayoutRulesFamilyImpl::getSpecializationConstantRules() { return nullptr; } -LayoutRulesImpl* CPULayoutRulesFamilyImpl::getShaderStorageBufferRules(TargetRequest*) +LayoutRulesImpl* CPULayoutRulesFamilyImpl::getShaderStorageBufferRules(CompilerOptionSet&) { return nullptr; } -LayoutRulesImpl* CPULayoutRulesFamilyImpl::getParameterBlockRules(TargetRequest*) +LayoutRulesImpl* CPULayoutRulesFamilyImpl::getParameterBlockRules(CompilerOptionSet&) { // Not clear - just use similar to CPU return &kCPULayoutRulesImpl_; @@ -1437,7 +1437,7 @@ LayoutRulesImpl* CPULayoutRulesFamilyImpl::getShaderRecordConstantBufferRules() return &kCPULayoutRulesImpl_; } -LayoutRulesImpl* CPULayoutRulesFamilyImpl::getStructuredBufferRules(TargetRequest*) +LayoutRulesImpl* CPULayoutRulesFamilyImpl::getStructuredBufferRules(CompilerOptionSet&) { return &kCPULayoutRulesImpl_; } @@ -1449,7 +1449,7 @@ LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getAnyValueRules() return &kCUDAAnyValueLayoutRulesImpl_; } -LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getConstantBufferRules(TargetRequest*) +LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getConstantBufferRules(CompilerOptionSet&) { return &kCUDALayoutRulesImpl_; } @@ -1476,11 +1476,11 @@ LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getSpecializationConstantRules() { return nullptr; } -LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getShaderStorageBufferRules(TargetRequest*) +LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getShaderStorageBufferRules(CompilerOptionSet&) { return nullptr; } -LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getParameterBlockRules(TargetRequest*) +LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getParameterBlockRules(CompilerOptionSet&) { // Not clear - just use similar to CPU return &kCUDALayoutRulesImpl_; @@ -1504,7 +1504,7 @@ LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getShaderRecordConstantBufferRules() return &kCUDALayoutRulesImpl_; } -LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getStructuredBufferRules(TargetRequest*) +LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getStructuredBufferRules(CompilerOptionSet&) { return &kCUDALayoutRulesImpl_; } @@ -1566,9 +1566,9 @@ TypeLayoutContext getInitialLayoutContextForTarget(TargetRequest* targetReq, Pro TypeLayoutContext context; context.astBuilder = astBuilder; context.targetReq = targetReq; - context.programLayout = programLayout; + context.programLayout = programLayout; context.rules = nullptr; - context.matrixLayoutMode = targetReq->getDefaultMatrixLayoutMode(); + context.matrixLayoutMode = targetReq->getOptionSet().getMatrixLayoutMode(); if (auto hlslToVulkanLayoutOptions = targetReq->getHLSLToVulkanLayoutOptions()) { @@ -1577,7 +1577,7 @@ TypeLayoutContext getInitialLayoutContextForTarget(TargetRequest* targetReq, Pro if( rulesFamily ) { - context.rules = rulesFamily->getConstantBufferRules(targetReq); + context.rules = rulesFamily->getConstantBufferRules(targetReq->getOptionSet()); } return context; @@ -1764,15 +1764,15 @@ bool isCUDATarget(TargetRequest* targetReq) } } -SourceLanguage getIntermediateSourceLanguageForTarget(TargetRequest* req) +SourceLanguage getIntermediateSourceLanguageForTarget(TargetProgram* targetProgram) { // If we are emitting directly, there is no intermediate source language - if (req->shouldEmitSPIRVDirectly()) + if (targetProgram->getOptionSet().shouldEmitSPIRVDirectly()) { return SourceLanguage::Unknown; } - switch (req->getTarget()) + switch (targetProgram->getTargetReq()->getTarget()) { case CodeGenTarget::GLSL: case CodeGenTarget::GLSL_Vulkan: @@ -1843,7 +1843,7 @@ static bool isSM5OrEarlier(TargetRequest* targetReq) if(!isD3DTarget(targetReq)) return false; - auto profile = targetReq->getTargetProfile(); + auto profile = targetReq->getOptionSet().getProfile(); if(profile.getFamily() == ProfileFamily::DX) { @@ -1859,7 +1859,7 @@ static bool isSM5_1OrLater(TargetRequest* targetReq) if(!isD3DTarget(targetReq)) return false; - auto profile = targetReq->getTargetProfile(); + auto profile = targetReq->getOptionSet().getProfile(); if(profile.getFamily() == ProfileFamily::DX) { @@ -2735,7 +2735,7 @@ RefPtr<TypeLayout> createConstantBufferTypeLayoutIfNeeded( return _createParameterGroupTypeLayout( context - .with(context.targetReq->getDefaultMatrixLayoutMode()), + .with(context.targetReq->getOptionSet().getMatrixLayoutMode()), nullptr, elementTypeLayout); } @@ -2767,11 +2767,11 @@ static RefPtr<TypeLayout> _createParameterGroupTypeLayout( LayoutRulesImpl* getParameterBufferElementTypeLayoutRules( ParameterGroupType* parameterGroupType, LayoutRulesImpl* rules, - TargetRequest* targetRequest) + CompilerOptionSet& compilerOptions) { if( as<ConstantBufferType>(parameterGroupType) ) { - return rules->getLayoutRulesFamily()->getConstantBufferRules(targetRequest); + return rules->getLayoutRulesFamily()->getConstantBufferRules(compilerOptions); } else if( as<TextureBufferType>(parameterGroupType) ) { @@ -2787,11 +2787,11 @@ LayoutRulesImpl* getParameterBufferElementTypeLayoutRules( } else if( as<GLSLShaderStorageBufferType>(parameterGroupType) ) { - return rules->getLayoutRulesFamily()->getShaderStorageBufferRules(targetRequest); + return rules->getLayoutRulesFamily()->getShaderStorageBufferRules(compilerOptions); } else if (as<ParameterBlockType>(parameterGroupType)) { - return rules->getLayoutRulesFamily()->getParameterBlockRules(targetRequest); + return rules->getLayoutRulesFamily()->getParameterBlockRules(compilerOptions); } else { @@ -2810,7 +2810,7 @@ RefPtr<TypeLayout> createParameterGroupTypeLayout( auto elementTypeRules = getParameterBufferElementTypeLayoutRules( parameterGroupType, parameterGroupRules, - context.targetReq); + context.targetReq->getOptionSet()); auto elementType = parameterGroupType->getElementType(); @@ -2831,7 +2831,7 @@ createStructuredBufferWithCounterTypeLayout( { auto typeLayout = createStructuredBufferTypeLayout(context, kind, structuredBufferType, elementTypeLayout); - const auto structuredBufferLayoutRules = context.getRulesFamily()->getStructuredBufferRules(context.targetReq); + const auto structuredBufferLayoutRules = context.getRulesFamily()->getStructuredBufferRules(context.targetReq->getOptionSet()); const auto counterType = context.astBuilder->getIntType(); const auto counterBufferType = context.astBuilder->getRWStructuredBufferType(counterType); @@ -2916,7 +2916,7 @@ createStructuredBufferTypeLayout( Type* elementType) { // look up the appropriate rules via the `LayoutRulesFamily` - auto structuredBufferLayoutRules = context.getRulesFamily()->getStructuredBufferRules(context.targetReq); + auto structuredBufferLayoutRules = context.getRulesFamily()->getStructuredBufferRules(context.targetReq->getOptionSet()); // Create and save type layout for the buffer contents. auto elementTypeLayout = createTypeLayoutWith( diff --git a/source/slang/slang-type-layout.h b/source/slang/slang-type-layout.h index 23b70d59d..f11ee342e 100644 --- a/source/slang/slang-type-layout.h +++ b/source/slang/slang-type-layout.h @@ -1052,14 +1052,14 @@ struct LayoutRulesImpl struct LayoutRulesFamilyImpl { virtual LayoutRulesImpl* getAnyValueRules() = 0; - virtual LayoutRulesImpl* getConstantBufferRules(TargetRequest* request) = 0; + virtual LayoutRulesImpl* getConstantBufferRules(CompilerOptionSet& compilerOptions) = 0; virtual LayoutRulesImpl* getPushConstantBufferRules() = 0; virtual LayoutRulesImpl* getTextureBufferRules() = 0; virtual LayoutRulesImpl* getVaryingInputRules() = 0; virtual LayoutRulesImpl* getVaryingOutputRules() = 0; virtual LayoutRulesImpl* getSpecializationConstantRules()= 0; - virtual LayoutRulesImpl* getShaderStorageBufferRules(TargetRequest* request) = 0; - virtual LayoutRulesImpl* getParameterBlockRules(TargetRequest* request) = 0; + virtual LayoutRulesImpl* getShaderStorageBufferRules(CompilerOptionSet& compilerOptions) = 0; + virtual LayoutRulesImpl* getParameterBlockRules(CompilerOptionSet& compilerOptions) = 0; virtual LayoutRulesImpl* getRayPayloadParameterRules() = 0; virtual LayoutRulesImpl* getCallablePayloadParameterRules() = 0; @@ -1067,7 +1067,7 @@ struct LayoutRulesFamilyImpl virtual LayoutRulesImpl* getShaderRecordConstantBufferRules() = 0; - virtual LayoutRulesImpl* getStructuredBufferRules(TargetRequest* request) = 0; + virtual LayoutRulesImpl* getStructuredBufferRules(CompilerOptionSet& compilerOptions) = 0; }; /// A custom tuple to capture the outputs of type layout @@ -1258,7 +1258,7 @@ private: // the ordering of all global generic type paramters. // TypeLayoutContext getInitialLayoutContextForTarget( - TargetRequest* targetReq, + TargetRequest* targetRequest, ProgramLayout* programLayout); /// Direction(s) of a varying shader parameter diff --git a/source/slang/slang-workspace-version.cpp b/source/slang/slang-workspace-version.cpp index 0826ca557..a07ef75cc 100644 --- a/source/slang/slang-workspace-version.cpp +++ b/source/slang/slang-workspace-version.cpp @@ -519,7 +519,7 @@ void WorkspaceVersion::ensureWorkspaceFlavor(UnownedStringSlice path) // Setup linkage for vfx files. // TODO: consider supporting this as an external config file. flavor = WorkspaceFlavor::VFX; - linkage->setEnableEffectAnnotations(true); + linkage->m_optionSet.set(CompilerOptionName::EnableEffectAnnotations, true); linkage->addPreprocessorDefine("VS", "__file_decl"); linkage->addPreprocessorDefine("CS", "__file_decl"); linkage->addPreprocessorDefine("GS", "__file_decl"); diff --git a/source/slang/slang.cpp b/source/slang/slang.cpp index 395285b41..498dc67f5 100644 --- a/source/slang/slang.cpp +++ b/source/slang/slang.cpp @@ -169,7 +169,7 @@ void Session::init() // Built in linkage uses the built in builder m_builtinLinkage = new Linkage(this, builtinAstBuilder, nullptr); - m_builtinLinkage->debugInfoLevel = DebugInfoLevel::None; + m_builtinLinkage->m_optionSet.set(CompilerOptionName::DebugInformation, DebugInfoLevel::None); // Because the `Session` retains the builtin `Linkage`, // we need to make sure that the parent pointer inside @@ -578,7 +578,7 @@ static T makeFromSizeVersioned(const uint8_t* src) // The size to copy is the minimum on the two sizes const auto copySize = std::min(srcSize, dstSize); - ::memcpy(&dst, &src, copySize); + ::memcpy(&dst, src, copySize); // The final struct size is the destination size dst.structureSize = dstSize; @@ -587,11 +587,14 @@ static T makeFromSizeVersioned(const uint8_t* src) } SLANG_NO_THROW SlangResult SLANG_MCALL Session::createSession( - slang::SessionDesc const& desc, + slang::SessionDesc const& inDesc, slang::ISession** outSession) { RefPtr<ASTBuilder> astBuilder(new ASTBuilder(m_sharedASTBuilder, "Session::astBuilder")); + slang::SessionDesc desc = makeFromSizeVersioned<slang::SessionDesc>((uint8_t*)&inDesc); + RefPtr<Linkage> linkage = new Linkage(this, astBuilder, getBuiltinLinkage()); + linkage->m_optionSet.load(desc.compilerOptionEntryCount, desc.compilerOptionEntries); { const Int targetCount = desc.targetCount; @@ -603,13 +606,6 @@ SLANG_NO_THROW SlangResult SLANG_MCALL Session::createSession( } } - linkage->setFlags(desc.flags); - - if(desc.flags & slang::kSessionFlag_FalcorCustomSharedKeywordSemantics) - { - linkage->m_useFalcorCustomSharedKeywordSemantics = true; - } - linkage->setMatrixLayoutMode(desc.defaultMatrixLayoutMode); Int searchPathCount = desc.searchPathCount; @@ -632,9 +628,8 @@ SLANG_NO_THROW SlangResult SLANG_MCALL Session::createSession( if (desc.structureSize >= offsetof(slang::SessionDesc, enableEffectAnnotations)) { - linkage->setEnableEffectAnnotations(desc.enableEffectAnnotations); + linkage->m_optionSet.set(CompilerOptionName::EnableEffectAnnotations, desc.enableEffectAnnotations); } - *outSession = asExternal(linkage.detach()); return SLANG_OK; } @@ -836,10 +831,57 @@ SLANG_NO_THROW SlangResult SLANG_MCALL Session::setSPIRVCoreGrammar(char const* return spirvCoreGrammarInfo ? SLANG_OK : SLANG_FAIL; } +struct ParsedCommandLineData : public ISlangUnknown, public ComObject +{ + SLANG_COM_OBJECT_IUNKNOWN_ALL + + ISlangUnknown* getInterface(const Slang::Guid& guid) + { + if (guid == ISlangUnknown::getTypeGuid()) + return this; + return nullptr; + } + List<SerializedOptionsData> options; + List<slang::TargetDesc> targets; +}; + +SLANG_NO_THROW SlangResult SLANG_MCALL Session::parseCommandLineArguments( + int argc, + const char* const* argv, + slang::SessionDesc* outDesc, + ISlangUnknown** outAllocation) +{ + if (outDesc->structureSize < sizeof(slang::SessionDesc)) + return SLANG_E_BUFFER_TOO_SMALL; + RefPtr<ParsedCommandLineData> outData = new ParsedCommandLineData(); + SerializedOptionsData optionData; + RefPtr<EndToEndCompileRequest> tempReq = new EndToEndCompileRequest(this); + tempReq->processCommandLineArguments(argv, argc); + tempReq->getOptionSet().serialize(&optionData); + outData->options.add(optionData); + for (auto target : tempReq->getLinkage()->targets) + { + slang::TargetDesc tdesc; + SerializedOptionsData targetOptionData; + tempReq->getTargetOptionSet(target).serialize(&targetOptionData); + outData->options.add(targetOptionData); + tdesc.compilerOptionEntryCount = (uint32_t)targetOptionData.entries.getCount(); + tdesc.compilerOptionEntries = targetOptionData.entries.getBuffer(); + outData->targets.add(tdesc); + } + outDesc->compilerOptionEntryCount = (uint32_t)optionData.entries.getCount(); + outDesc->compilerOptionEntries = optionData.entries.getBuffer(); + outDesc->targetCount = outData->targets.getCount(); + outDesc->targets = outData->targets.getBuffer(); + *outAllocation = outData.get(); + outData->addRef(); + return SLANG_OK; +} + Profile getEffectiveProfile(EntryPoint* entryPoint, TargetRequest* target) { auto entryPointProfile = entryPoint->getProfile(); - auto targetProfile = target->getTargetProfile(); + auto targetProfile = target->getOptionSet().getProfile(); // Depending on the target *format* we might have to restrict the // profile family to one that makes sense. @@ -959,6 +1001,7 @@ Linkage::Linkage(Session* session, ASTBuilder* astBuilder, Linkage* builtinLinka , m_retainedSession(session) , m_sourceManager(&m_defaultSourceManager) , m_astBuilder(astBuilder) + , m_cmdLineContext(new CommandLineContext()) { if (builtinLinkage) m_astBuilder->m_cachedNodes = builtinLinkage->getASTBuilder()->m_cachedNodes; @@ -975,24 +1018,6 @@ Linkage::Linkage(Session* session, ASTBuilder* astBuilder, Linkage* builtinLinka for (const auto& nameToMod : builtinLinkage->mapNameToLoadedModules) mapNameToLoadedModules.add(nameToMod); } - - { - RefPtr<CommandLineContext> context = new CommandLineContext; - m_downstreamArgs = DownstreamArgs(context); - - // Add all of the possible names we allow for downstream tools - { - for (Index i = SLANG_PASS_THROUGH_NONE + 1; i < SLANG_PASS_THROUGH_COUNT_OF; ++i) - { - m_downstreamArgs.addName(TypeTextUtil::getPassThroughName(SlangPassThrough(i))); - } - - // Generic downstream tool - m_downstreamArgs.addName("downstream"); - // Generic downstream linker - m_downstreamArgs.addName("linker"); - } - } } ISlangUnknown* Linkage::getInterface(const Guid& guid) @@ -1008,6 +1033,18 @@ Linkage::~Linkage() destroyTypeCheckingCache(); } +SearchDirectoryList& Linkage::getSearchDirectories() +{ + auto list = m_optionSet.getArray(CompilerOptionName::Include); + if (list.getCount() != searchDirectoryCache.searchDirectories.getCount()) + { + searchDirectoryCache.searchDirectories.clear(); + for (auto dir : list) + searchDirectoryCache.searchDirectories.add(SearchDirectory(dir.stringValue)); + } + return searchDirectoryCache; +} + TypeCheckingCache* Linkage::getTypeCheckingCache() { if (!m_typeCheckingCache) @@ -1036,11 +1073,15 @@ void Linkage::addTarget( auto targetIndex = addTarget(CodeGenTarget(desc.format)); auto target = targets[targetIndex]; - target->setFloatingPointMode(FloatingPointMode(desc.floatingPointMode)); - target->addTargetFlags(desc.flags); - target->setTargetProfile(Profile(desc.profile)); - target->setLineDirectiveMode(LineDirectiveMode(desc.lineDirectiveMode)); - target->setForceGLSLScalarBufferLayout(desc.forceGLSLScalarBufferLayout); + auto& optionSet = target->getOptionSet(); + optionSet.inheritFrom(m_optionSet); + + optionSet.set(CompilerOptionName::FloatingPointMode, FloatingPointMode(desc.floatingPointMode)); + optionSet.addTargetFlags(desc.flags); + optionSet.setProfile(Profile(desc.profile)); + optionSet.set(CompilerOptionName::LineDirectiveMode, LineDirectiveMode(desc.lineDirectiveMode)); + optionSet.set(CompilerOptionName::GLSLForceScalarLayout, desc.forceGLSLScalarBufferLayout); + } #if 0 @@ -1064,6 +1105,7 @@ SLANG_NO_THROW slang::IModule* SLANG_MCALL Linkage::loadModule( SLANG_AST_BUILDER_RAII(getASTBuilder()); DiagnosticSink sink(getSourceManager(), Lexer::sourceLocationLexer); + applySettingsToDiagnosticSink(&sink, &sink, m_optionSet); if (isInLanguageServer()) { @@ -1097,10 +1139,13 @@ slang::IModule* Linkage::loadModuleFromBlob( SLANG_AST_BUILDER_RAII(getASTBuilder()); DiagnosticSink sink(getSourceManager(), Lexer::sourceLocationLexer); + applySettingsToDiagnosticSink(&sink, &sink, m_optionSet); + if (isInLanguageServer()) { sink.setFlags(DiagnosticSink::Flag::HumaneLoc | DiagnosticSink::Flag::LanguageServer); } + try { @@ -1177,6 +1222,7 @@ SLANG_NO_THROW SlangResult SLANG_MCALL Linkage::createCompositeComponentType( } DiagnosticSink sink(getSourceManager(), Lexer::sourceLocationLexer); + applySettingsToDiagnosticSink(&sink, &sink, m_optionSet); List<RefPtr<ComponentType>> childComponents; for( Int cc = 0; cc < componentTypeCount; ++cc ) @@ -1391,6 +1437,8 @@ SLANG_NO_THROW SlangResult SLANG_MCALL Linkage::createTypeConformanceComponentTy RefPtr<TypeConformance> result; DiagnosticSink sink; + applySettingsToDiagnosticSink(&sink, &sink, m_optionSet); + try { SharedSemanticsContext sharedSemanticsContext(this, nullptr, &sink); @@ -1437,47 +1485,12 @@ void Linkage::buildHash(DigestBuilder<SHA1>& builder, SlangInt targetIndex) auto version = String(getBuildTagString()); builder.append(version); - // Add the search directory paths to the hash - auto searchDirectoryList = getSearchDirectories().searchDirectories; - for (auto& searchDir : searchDirectoryList) - { - auto searchPath = searchDir.path; - builder.append(searchPath); - } - - // Add the preprocessor definitions to the hash - for (const auto& [defName, defVal] : preprocessorDefinitions) - { - builder.append(defName); - builder.append(defVal); - } - - // Add compiler settings to hash - builder.append(defaultMatrixLayoutMode); - builder.append(debugInfoLevel); - builder.append(debugInfoFormat); - builder.append(optimizationLevel); + // Add compiler options, including search path, preprocessor includes, etc. + m_optionSet.buildHash(builder); // Add the target specified by targetIndex auto targetReq = targets[targetIndex]; - builder.append(targetReq->getTarget()); - builder.append(targetReq->getTargetProfile().raw); - builder.append(targetReq->getTargetFlags()); - builder.append(targetReq->getFloatingPointMode()); - builder.append(targetReq->getLineDirectiveMode()); - builder.append(targetReq->getForceGLSLScalarBufferLayout()); - builder.append(targetReq->getDefaultMatrixLayoutMode()); - builder.append(targetReq->shouldDumpIntermediates()); - builder.append(targetReq->shouldTrackLiveness()); - - auto cookedCapabilities = targetReq->getTargetCaps().getExpandedAtoms(); - builder.append(cookedCapabilities.getCount()); - for (auto& capabilityConjunction : cookedCapabilities) - { - builder.append(capabilityConjunction.getExpandedAtoms().getCount()); - for (auto atom : capabilityConjunction.getExpandedAtoms()) - builder.append(atom); - } + targetReq->getOptionSet().buildHash(builder); const PassThroughMode passThroughMode = getDownstreamCompilerRequiredForTarget(targetReq->getTarget()); const SourceLanguage sourceLanguage = getDefaultSourceLanguageForDownstreamCompiler(passThroughMode); @@ -1511,7 +1524,7 @@ void Linkage::buildHash(DigestBuilder<SHA1>& builder, SlangInt targetIndex) SlangResult Linkage::addSearchPath( char const* path) { - searchDirectories.searchDirectories.add(Slang::SearchDirectory(path)); + m_optionSet.add(CompilerOptionName::Include, String(path)); return SLANG_OK; } @@ -1519,14 +1532,18 @@ SlangResult Linkage::addPreprocessorDefine( char const* name, char const* value) { - preprocessorDefinitions[name] = value; + CompilerOptionValue val; + val.kind = CompilerOptionValueKind::String; + val.stringValue = name; + val.stringValue2 = value; + m_optionSet.add(CompilerOptionName::MacroDefine, val); return SLANG_OK; } SlangResult Linkage::setMatrixLayoutMode( SlangMatrixLayoutMode mode) { - defaultMatrixLayoutMode = MatrixLayoutMode(mode); + m_optionSet.setMatrixLayoutMode((MatrixLayoutMode)mode); return SLANG_OK; } @@ -1536,32 +1553,30 @@ SlangResult Linkage::setMatrixLayoutMode( TargetRequest::TargetRequest(Linkage* linkage, CodeGenTarget format) : linkage(linkage) - , format(format) -{} - - -Session* TargetRequest::getSession() { - return linkage->getSessionImpl(); + optionSet = linkage->m_optionSet; + optionSet.add(CompilerOptionName::Target, format); } -MatrixLayoutMode TargetRequest::getDefaultMatrixLayoutMode() +TargetRequest::TargetRequest(const TargetRequest& other) + : linkage(other.linkage), optionSet(other.optionSet) { - return linkage->getDefaultMatrixLayoutMode(); } -void TargetRequest::setHLSLToVulkanLayoutOptions(HLSLToVulkanLayoutOptions* opts) + +Session* TargetRequest::getSession() { - if (isKhronosTarget(this)) - { - hlslToVulkanLayoutOptions = opts; - } + return linkage->getSessionImpl(); } -void TargetRequest::addCapability(CapabilityName capability) +HLSLToVulkanLayoutOptions* TargetRequest::getHLSLToVulkanLayoutOptions() { - rawCapabilities.add(capability); - cookedCapabilities = CapabilitySet::makeEmpty(); + if (!hlslToVulkanOptions) + { + hlslToVulkanOptions = new HLSLToVulkanLayoutOptions(); + hlslToVulkanOptions->loadFromOptionSet(optionSet); + } + return hlslToVulkanOptions.get(); } CapabilitySet TargetRequest::getTargetCaps() @@ -1590,7 +1605,7 @@ CapabilitySet TargetRequest::getTargetCaps() List<CapabilityName> atoms; bool isGLSLTarget = false; - switch(format) + switch(getTarget()) { case CodeGenTarget::GLSL: case CodeGenTarget::GLSL_Vulkan: @@ -1600,7 +1615,7 @@ CapabilitySet TargetRequest::getTargetCaps() break; case CodeGenTarget::SPIRV: case CodeGenTarget::SPIRVAssembly: - if (targetFlags & SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY) + if (getOptionSet().shouldEmitSPIRVDirectly()) { atoms.add(CapabilityName::spirv_1_5); } @@ -1645,8 +1660,9 @@ CapabilitySet TargetRequest::getTargetCaps() CapabilitySet latestSpirvCapSet = CapabilitySet(CapabilityName::spirv_latest); CapabilityName latestSpirvAtom = (CapabilityName)latestSpirvCapSet.getExpandedAtoms()[0].getExpandedAtoms().getLast(); - for (auto atom : rawCapabilities) + for (auto atomVal : optionSet.getArray(CompilerOptionName::Capability)) { + auto atom = (CapabilityName)atomVal.intValue; if (isGLSLTarget) { // If we are emitting GLSL code, we need to @@ -1740,16 +1756,11 @@ Scope* TranslationUnitRequest::getLanguageScope() Dictionary<String, String> TranslationUnitRequest::getCombinedPreprocessorDefinitions() { - // TODO(JS): - // Note! that a adding a define twice will cause an exception in debug builds - // that may be desirable or not... Dictionary<String, String> combinedPreprocessorDefinitions; - for (const auto& def : compileRequest->getLinkage()->preprocessorDefinitions) - combinedPreprocessorDefinitions.add(def); - for (const auto& def : compileRequest->preprocessorDefinitions) - combinedPreprocessorDefinitions.add(def); for (const auto& def : preprocessorDefinitions) - combinedPreprocessorDefinitions.add(def); + combinedPreprocessorDefinitions.addIfNotExists(def); + for (const auto& def : compileRequest->optionSet.getArray(CompilerOptionName::MacroDefine)) + combinedPreprocessorDefinitions.addIfNotExists(def.stringValue, def.stringValue2); // Define standard macros, if not already defined. This style assumes using `#if __SOME_VAR` style, as in // @@ -2098,6 +2109,7 @@ FrontEndCompileRequest::FrontEndCompileRequest( : CompileRequestBase(linkage, sink) , m_writers(writers) { + optionSet.inheritFrom(linkage->m_optionSet); } /// Handlers for preprocessor callbacks to use when doing ordinary front-end compilation @@ -2386,7 +2398,7 @@ void FrontEndCompileRequest::parseTranslationUnit( // Here we should probably be using the searchDirectories on the FrontEndCompileRequest. // If searchDirectories.parent pointed to the one in the Linkage would mean linkage paths // would be checked too (after those on the FrontEndCompileRequest). - IncludeSystem includeSystem(&linkage->searchDirectories, linkage->getFileSystemExt(), linkage->getSourceManager()); + IncludeSystem includeSystem(&linkage->getSearchDirectories(), linkage->getFileSystemExt(), linkage->getSourceManager()); auto combinedPreprocessorDefinitions = translationUnit->getCombinedPreprocessorDefinitions(); @@ -2458,12 +2470,12 @@ void FrontEndCompileRequest::parseTranslationUnit( break; } - if (outputIncludes) + if (optionSet.getBoolOption(CompilerOptionName::OutputIncludes)) { _outputIncludes(translationUnit->getSourceFiles(), getSink()->getSourceManager(), getSink()); } - if (outputPreprocessor) + if (optionSet.getBoolOption(CompilerOptionName::PreprocessorOutput)) { if (m_writers) { @@ -2484,7 +2496,7 @@ void FrontEndCompileRequest::parseTranslationUnit( // Let's try dumping - if (shouldDumpAST) + if (optionSet.getBoolOption(CompilerOptionName::DumpAst)) { StringBuilder buf; SourceWriter writer(linkage->getSourceManager(), LineDirectiveMode::None, nullptr); @@ -2660,7 +2672,7 @@ SlangResult FrontEndCompileRequest::executeActionsInner() parseTranslationUnit(translationUnit); } - if (outputPreprocessor) + if (optionSet.getBoolOption(CompilerOptionName::PreprocessorOutput)) { // If doing pre-processor output, then we are done return SLANG_OK; @@ -2675,7 +2687,7 @@ SlangResult FrontEndCompileRequest::executeActionsInner() return SLANG_FAIL; // After semantic checking is performed we can try and output doc information for this - if (shouldDocument) + if (optionSet.getBoolOption(CompilerOptionName::Doc)) { // Not 100% clear where best to get the ASTBuilder from, but from the linkage shouldn't // cause any problems with scoping @@ -2820,6 +2832,11 @@ SlangResult EndToEndCompileRequest::executeActionsInner() } } + // Update compiler settings in target requests. + for (auto target : getLinkage()->targets) + target->getOptionSet().inheritFrom(getOptionSet()); + m_frontEndReq->optionSet = getOptionSet(); + // We only do parsing and semantic checking if we *aren't* doing // a pass-through compilation. // @@ -2828,7 +2845,7 @@ SlangResult EndToEndCompileRequest::executeActionsInner() SLANG_RETURN_ON_FAIL(getFrontEndReq()->executeActionsInner()); } - if (getFrontEndReq()->outputPreprocessor) + if (getOptionSet().getBoolOption(CompilerOptionName::PreprocessorOutput)) { return SLANG_OK; } @@ -2836,8 +2853,7 @@ SlangResult EndToEndCompileRequest::executeActionsInner() // If command line specifies to skip codegen, we exit here. // Note: this is a debugging option. // - if (m_shouldSkipCodegen || - ((getFrontEndReq()->compileFlags & SLANG_COMPILE_FLAG_NO_CODEGEN) != 0)) + if (getOptionSet().getBoolOption(CompilerOptionName::SkipCodeGen)) { // We will use the program (and matching layout information) // that was computed in the front-end for all subsequent @@ -2848,7 +2864,7 @@ SlangResult EndToEndCompileRequest::executeActionsInner() m_specializedEntryPoints = getFrontEndReq()->getUnspecializedEntryPoints(); SLANG_RETURN_ON_FAIL(maybeCreateContainer()); - + SLANG_RETURN_ON_FAIL(maybeWriteContainer(m_containerOutputPath)); return SLANG_OK; @@ -2875,6 +2891,7 @@ SlangResult EndToEndCompileRequest::executeActionsInner() // for (auto targetReq : getLinkage()->targets) { + targetReq->getOptionSet().inheritFrom(getLinkage()->m_optionSet); auto targetProgram = m_specializedGlobalAndEntryPointsComponentType->getTargetProgram(targetReq); targetProgram->getOrCreateLayout(getSink()); } @@ -3388,7 +3405,7 @@ RefPtr<Module> Linkage::findOrImportModule( // Next, try to find the file of the given name, // using our ordinary include-handling logic. - IncludeSystem includeSystem(&searchDirectories, getFileSystemExt(), getSourceManager()); + IncludeSystem includeSystem(&getSearchDirectories(), getFileSystemExt(), getSourceManager()); // Get the original path info PathInfo pathIncludedFromInfo = getSourceManager()->getPathInfo(loc, SourceLocType::Actual); @@ -3458,7 +3475,8 @@ SourceFile* Linkage::findFile(Name* name, SourceLoc loc, IncludeSystem& outInclu // Next, try to find the file of the given name, // using our ordinary include-handling logic. - outIncludeSystem = IncludeSystem(&searchDirectories, getFileSystemExt(), getSourceManager()); + auto searchDirs = getSearchDirectories(); + outIncludeSystem = IncludeSystem(&searchDirs, getFileSystemExt(), getSourceManager()); // Get the original path info PathInfo pathIncludedFromInfo = getSourceManager()->getPathInfo(loc, SourceLocType::Actual); @@ -3808,7 +3826,6 @@ ISlangUnknown* ComponentType::getInterface(Guid const& guid) { return static_cast<slang::IComponentType*>(this); } - return nullptr; } @@ -3947,6 +3964,7 @@ SLANG_NO_THROW SlangResult SLANG_MCALL ComponentType::getEntryPointCode( auto targetProgram = getTargetProgram(target); DiagnosticSink sink(linkage->getSourceManager(), Lexer::sourceLocationLexer); + applySettingsToDiagnosticSink(&sink, &sink, m_optionSet); IArtifact* artifact = targetProgram->getOrCreateEntryPointResult(entryPointIndex, &sink); sink.getBlobIfNeeded(outDiagnostics); @@ -4008,6 +4026,8 @@ SLANG_NO_THROW SlangResult SLANG_MCALL ComponentType::getEntryPointHostCallable( auto targetProgram = getTargetProgram(target); DiagnosticSink sink(linkage->getSourceManager(), Lexer::sourceLocationLexer); + applySettingsToDiagnosticSink(&sink, &sink, m_optionSet); + IArtifact* artifact = targetProgram->getOrCreateEntryPointResult(entryPointIndex, &sink); sink.getBlobIfNeeded(outDiagnostics); @@ -4131,6 +4151,23 @@ SLANG_NO_THROW SlangResult SLANG_MCALL ComponentType::link( return SLANG_OK; } +SLANG_NO_THROW SlangResult SLANG_MCALL ComponentType::linkWithOptions( + slang::IComponentType** outLinkedComponentType, + uint32_t count, + slang::CompilerOptionEntry* entries, + ISlangBlob** outDiagnostics) +{ + SLANG_RETURN_ON_FAIL(link(outLinkedComponentType, outDiagnostics)); + + auto linked = *outLinkedComponentType; + + if (linked) + { + static_cast<ComponentType*>(linked)->getOptionSet().load(count, entries); + } + + return SLANG_OK; +} /// Visitor used by `ComponentType::enumerateModules` struct EnumerateModulesVisitor : ComponentTypeVisitor @@ -4875,13 +4912,12 @@ TargetProgram::TargetProgram( , m_targetReq(targetReq) { m_entryPointResults.setCount(componentType->getEntryPointCount()); + m_optionSet.overrideWith(m_program->getOptionSet()); + m_optionSet.inheritFrom(targetReq->getOptionSet()); } // - - - Session* CompileRequestBase::getSession() { return getLinkage()->getSessionImpl(); @@ -4981,6 +5017,7 @@ void Session::addBuiltinSource( SourceManager* sourceManager = getBuiltinSourceManager(); DiagnosticSink sink(sourceManager, Lexer::sourceLocationLexer); + RefPtr<FrontEndCompileRequest> compileRequest = new FrontEndCompileRequest( m_builtinLinkage, nullptr, @@ -5075,60 +5112,53 @@ void EndToEndCompileRequest::setFileSystem(ISlangFileSystem* fileSystem) void EndToEndCompileRequest::setCompileFlags(SlangCompileFlags flags) { - getFrontEndReq()->compileFlags = flags; + if (flags & SLANG_COMPILE_FLAG_NO_MANGLING) + getOptionSet().set(CompilerOptionName::NoMangle, true); + if (flags & SLANG_COMPILE_FLAG_NO_CODEGEN) + getOptionSet().set(CompilerOptionName::SkipCodeGen, true); + if (flags & SLANG_COMPILE_FLAG_OBFUSCATE) + getOptionSet().set(CompilerOptionName::Obfuscate, true); } SlangCompileFlags EndToEndCompileRequest::getCompileFlags() { - return getFrontEndReq()->compileFlags; + SlangCompileFlags result = 0; + if (getOptionSet().getBoolOption(CompilerOptionName::NoMangle)) + result |= SLANG_COMPILE_FLAG_NO_MANGLING; + if (getOptionSet().getBoolOption(CompilerOptionName::SkipCodeGen)) + result |= SLANG_COMPILE_FLAG_NO_CODEGEN; + if (getOptionSet().getBoolOption(CompilerOptionName::Obfuscate)) + result |= SLANG_COMPILE_FLAG_OBFUSCATE; + return result; } void EndToEndCompileRequest::setDumpIntermediates(int enable) { - shouldDumpIntermediates = (enable != 0); - - // Change all existing targets to use the new setting. - auto linkage = getLinkage(); - for (auto& target : linkage->targets) - { - target->setDumpIntermediates(enable != 0); - } + getOptionSet().set(CompilerOptionName::DumpIntermediates, enable); } void EndToEndCompileRequest::setTrackLiveness(bool v) { - enableLivenessTracking = v; - - // Change all existing targets to use the new setting. - auto linkage = getLinkage(); - for (auto& target : linkage->targets) - { - target->setTrackLiveness(v); - } + getOptionSet().set(CompilerOptionName::TrackLiveness, v); } void EndToEndCompileRequest::setDumpIntermediatePrefix(const char* prefix) { - m_dumpIntermediatePrefix = prefix; + getOptionSet().set(CompilerOptionName::DumpIntermediatePrefix, String(prefix)); } void EndToEndCompileRequest::setLineDirectiveMode(SlangLineDirectiveMode mode) { - // This method is deprecated and user should call `setTargetLineDirectiveMode` instead. - // We provide the implementation here for backward compatibility. - // Targets added later will use `m_lineDirectiveMode`, so we update it to the new `mode` - // set by the user. - m_lineDirectiveMode = LineDirectiveMode(mode); - - // Change all existing targets to use the new mode. - auto linkage = getLinkage(); - for (auto& target : linkage->targets) - target->setLineDirectiveMode(m_lineDirectiveMode); + getOptionSet().set(CompilerOptionName::LineDirectiveMode, mode); } void EndToEndCompileRequest::setCommandLineCompilerMode() { m_isCommandLineCompile = true; + + // legacy slangc tool defaults to column major layout. + if (!getOptionSet().hasOption(CompilerOptionName::MatrixLayoutRow)) + getOptionSet().setMatrixLayoutMode(kMatrixLayoutMode_ColumnMajor); } void EndToEndCompileRequest::_completeTargetRequest(UInt targetIndex) @@ -5137,14 +5167,7 @@ void EndToEndCompileRequest::_completeTargetRequest(UInt targetIndex) TargetRequest* targetRequest = linkage->targets[Index(targetIndex)]; - // If we have vulkan layout options, and the target is khronos add the options - if (m_hlslToVulkanLayoutOptions && isKhronosTarget(targetRequest)) - { - targetRequest->setHLSLToVulkanLayoutOptions(m_hlslToVulkanLayoutOptions); - } - - // Set the current line directive - targetRequest->setLineDirectiveMode(m_lineDirectiveMode); + targetRequest->getOptionSet().inheritFrom(getLinkage()->m_optionSet); } void EndToEndCompileRequest::setCodeGenTarget(SlangCompileTarget target) @@ -5165,45 +5188,39 @@ int EndToEndCompileRequest::addCodeGenTarget(SlangCompileTarget target) void EndToEndCompileRequest::setTargetProfile(int targetIndex, SlangProfileID profile) { - getLinkage()->targets[targetIndex]->setTargetProfile(Profile(profile)); -} - -void EndToEndCompileRequest::setHLSLToVulkanLayoutOptions(int targetIndex, HLSLToVulkanLayoutOptions* vulkanShiftOptions) -{ - getLinkage()->targets[targetIndex]->setHLSLToVulkanLayoutOptions(vulkanShiftOptions); + getTargetOptionSet(targetIndex).setProfile(Profile(profile)); } void EndToEndCompileRequest::setTargetFlags(int targetIndex, SlangTargetFlags flags) { - getLinkage()->targets[targetIndex]->addTargetFlags(flags); + getTargetOptionSet(targetIndex).setTargetFlags(flags); } void EndToEndCompileRequest::setTargetForceGLSLScalarBufferLayout(int targetIndex, bool value) { - getLinkage()->targets[targetIndex]->setForceGLSLScalarBufferLayout(value); + getTargetOptionSet(targetIndex).set(CompilerOptionName::GLSLForceScalarLayout, value); } void EndToEndCompileRequest::setTargetFloatingPointMode(int targetIndex, SlangFloatingPointMode mode) { - getLinkage()->targets[targetIndex]->setFloatingPointMode(FloatingPointMode(mode)); + getTargetOptionSet(targetIndex).set(CompilerOptionName::FloatingPointMode, FloatingPointMode(mode)); } void EndToEndCompileRequest::setMatrixLayoutMode(SlangMatrixLayoutMode mode) { - getLinkage()->setMatrixLayoutMode(mode); + getOptionSet().setMatrixLayoutMode((MatrixLayoutMode)mode); } void EndToEndCompileRequest::setTargetMatrixLayoutMode(int targetIndex, SlangMatrixLayoutMode mode) { - SLANG_UNUSED(targetIndex); - setMatrixLayoutMode(mode); + getTargetOptionSet(targetIndex).setMatrixLayoutMode(MatrixLayoutMode(mode)); } void EndToEndCompileRequest::setTargetLineDirectiveMode( SlangInt targetIndex, SlangLineDirectiveMode mode) { - getLinkage()->targets[targetIndex]->setLineDirectiveMode(LineDirectiveMode(mode)); + getTargetOptionSet(targetIndex).set(CompilerOptionName::LineDirectiveMode, LineDirectiveMode(mode)); } void EndToEndCompileRequest::overrideDiagnosticSeverity( @@ -5250,23 +5267,23 @@ SlangResult EndToEndCompileRequest::addTargetCapability(SlangInt targetIndex, Sl auto& targets = getLinkage()->targets; if(targetIndex < 0 || targetIndex >= targets.getCount()) return SLANG_E_INVALID_ARG; - targets[targetIndex]->addCapability(CapabilityName(capability)); + getTargetOptionSet(targetIndex).addCapabilityAtom(CapabilityName(capability)); return SLANG_OK; } void EndToEndCompileRequest::setDebugInfoLevel(SlangDebugInfoLevel level) { - getLinkage()->debugInfoLevel = DebugInfoLevel(level); + getOptionSet().set(CompilerOptionName::DebugInformation, DebugInfoLevel(level)); } void EndToEndCompileRequest::setDebugInfoFormat(SlangDebugInfoFormat format) { - getLinkage()->debugInfoFormat = DebugInfoFormat(format); + getOptionSet().set(CompilerOptionName::DebugInformationFormat, DebugInfoFormat(format)); } void EndToEndCompileRequest::setOptimizationLevel(SlangOptimizationLevel level) { - getLinkage()->optimizationLevel = OptimizationLevel(level); + getOptionSet().set(CompilerOptionName::Optimization, OptimizationLevel(level)); } void EndToEndCompileRequest::setOutputContainerFormat(SlangContainerFormat format) @@ -5281,17 +5298,17 @@ void EndToEndCompileRequest::setPassThrough(SlangPassThrough inPassThrough) void EndToEndCompileRequest::setReportDownstreamTime(bool value) { - m_reportDownstreamCompileTime = value; + getOptionSet().set(CompilerOptionName::ReportDownstreamTime, value); } void EndToEndCompileRequest::setReportPerfBenchmark(bool value) { - m_reportPerfBenchmark = value; + getOptionSet().set(CompilerOptionName::ReportPerfBenchmark, value); } void EndToEndCompileRequest::setSkipSPIRVValidation(bool value) { - m_skipSPIRVValidation = value; + getOptionSet().set(CompilerOptionName::SkipSPIRVValidation, value); } void EndToEndCompileRequest::setDiagnosticCallback(SlangDiagnosticCallback callback, void const* userData) @@ -5312,17 +5329,17 @@ ISlangWriter* EndToEndCompileRequest::getWriter(SlangWriterChannel chan) void EndToEndCompileRequest::addSearchPath(const char* path) { - getLinkage()->addSearchPath(path); + getOptionSet().addSearchPath(path); } void EndToEndCompileRequest::addPreprocessorDefine(const char* key, const char* value) { - getLinkage()->addPreprocessorDefine(key, value); + getOptionSet().addPreprocessorDefine(key, value); } void EndToEndCompileRequest::setEnableEffectAnnotations(bool value) { - getLinkage()->setEnableEffectAnnotations(value); + getOptionSet().set(CompilerOptionName::EnableEffectAnnotations, value); } char const* EndToEndCompileRequest::getDiagnosticOutput() @@ -5599,16 +5616,16 @@ SlangResult EndToEndCompileRequest::setTypeNameForEntryPointExistentialTypeParam void EndToEndCompileRequest::setAllowGLSLInput(bool value) { - getLinkage()->setAllowGLSLInput(value); + getOptionSet().set(CompilerOptionName::AllowGLSL, value); } -SlangResult EndToEndCompileRequest::EndToEndCompileRequest::compile() +SlangResult EndToEndCompileRequest::compile() { SlangResult res = SLANG_FAIL; double downstreamStartTime = 0.0; double totalStartTime = 0.0; - if (m_reportDownstreamCompileTime) + if (getOptionSet().getBoolOption(CompilerOptionName::ReportDownstreamTime)) { getSession()->getCompilerElapsedTime(&totalStartTime, &downstreamStartTime); } @@ -5665,7 +5682,7 @@ SlangResult EndToEndCompileRequest::EndToEndCompileRequest::compile() } #endif - if (m_reportDownstreamCompileTime) + if (getOptionSet().getBoolOption(CompilerOptionName::ReportDownstreamTime)) { double downstreamEndTime = 0; double totalEndTime = 0; @@ -5674,7 +5691,7 @@ SlangResult EndToEndCompileRequest::EndToEndCompileRequest::compile() String downstreamTimeStr = String(downstreamTime, "%.2f"); getSink()->diagnose(SourceLoc(), Diagnostics::downstreamCompileTime, downstreamTimeStr); } - if (m_reportPerfBenchmark) + if (getOptionSet().getBoolOption(CompilerOptionName::ReportPerfBenchmark)) { StringBuilder perfResult; PerformanceProfiler::getProfiler()->getResult(perfResult); @@ -5684,16 +5701,19 @@ SlangResult EndToEndCompileRequest::EndToEndCompileRequest::compile() // Repro dump handling { - if (m_dumpRepro.getLength()) + auto dumpRepro = getOptionSet().getStringOption(CompilerOptionName::DumpRepro); + auto dumpReproOnError = getOptionSet().getBoolOption(CompilerOptionName::DumpReproOnError); + + if (dumpRepro.getLength()) { - SlangResult saveRes = ReproUtil::saveState(this, m_dumpRepro); + SlangResult saveRes = ReproUtil::saveState(this, dumpRepro); if (SLANG_FAILED(saveRes)) { - getSink()->diagnose(SourceLoc(), Diagnostics::unableToWriteReproFile, m_dumpRepro); + getSink()->diagnose(SourceLoc(), Diagnostics::unableToWriteReproFile, dumpRepro); return saveRes; } } - else if (m_dumpReproOnError && SLANG_FAILED(res)) + else if (dumpReproOnError && SLANG_FAILED(res)) { String reproFileName; SlangResult saveRes = SLANG_FAIL; diff --git a/tests/compute/column-major.slang b/tests/compute/column-major.slang index ae4c008e9..dd89c5f41 100644 --- a/tests/compute/column-major.slang +++ b/tests/compute/column-major.slang @@ -3,9 +3,9 @@ // Unfortunately CPU and CUDA only work with row layout, so they have to be disabled here. //DISABLE_TEST(compute):COMPARE_COMPUTE_EX:-cpu -compute -output-using-type -compile-arg -O3 -shaderobj -//TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -output-using-type -shaderobj -//TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -output-using-type -dx12 -shaderobj -//TEST(compute, vulkan):COMPARE_COMPUTE_EX:-vk -compute -output-using-type -shaderobj +//TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -output-using-type -shaderobj -Xslang -matrix-layout-column-major +//TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -output-using-type -dx12 -shaderobj -Xslang -matrix-layout-column-major +//TEST(compute, vulkan):COMPARE_COMPUTE_EX:-vk -compute -output-using-type -shaderobj -Xslang -matrix-layout-column-major //DISABLE_TEST(compute):COMPARE_COMPUTE_EX:-cuda -compute -output-using-type -shaderobj // This data is in column major layout order.... diff --git a/tests/compute/column-major.slang.expected.txt b/tests/compute/column-major.slang.expected.txt index 14ab70a6a..1e24f3253 100644 --- a/tests/compute/column-major.slang.expected.txt +++ b/tests/compute/column-major.slang.expected.txt @@ -1,5 +1,5 @@ type: float +11.000000 +22.000000 +33.000000 1.000000 -2.000000 -3.000000 -141.000000 diff --git a/tests/compute/disable-warning.slang b/tests/compute/disable-warning.slang index 2fd2bde61..61c952358 100644 --- a/tests/compute/disable-warning.slang +++ b/tests/compute/disable-warning.slang @@ -1,4 +1,3 @@ -//TEST(smoke,compute):COMPARE_COMPUTE: -shaderobj -Xslang... -Wno-unrecommended-implicit-conversion -X. //TEST(smoke,compute):COMPARE_COMPUTE:-cpu -shaderobj -Xslang... -Wno-unrecommended-implicit-conversion -X. // Test to check warning disable @@ -11,7 +10,7 @@ void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID) { uint v = dispatchThreadID.x; // This coercion loses data and would normally produce a warning - int v1 = v; + int16_t v1 = v; outputBuffer[dispatchThreadID.x] = v1; }
\ No newline at end of file diff --git a/tests/reflection/matrix-layout.slang b/tests/reflection/matrix-layout.slang index 2f0fe6a41..0b81d4cdb 100644 --- a/tests/reflection/matrix-layout.slang +++ b/tests/reflection/matrix-layout.slang @@ -1,4 +1,4 @@ -//TEST:REFLECTION:-profile ps_4_0 -target hlsl -no-codegen +//TEST:REFLECTION:-profile ps_4_0 -target hlsl -no-codegen -matrix-layout-column-major //TEST:REFLECTION:-profile ps_4_0 -target hlsl -no-codegen -matrix-layout-row-major // Test that we apply matrix layout rules correctly. diff --git a/tools/gfx-unit-test/link-time-options.cpp b/tools/gfx-unit-test/link-time-options.cpp new file mode 100644 index 000000000..f14a918e8 --- /dev/null +++ b/tools/gfx-unit-test/link-time-options.cpp @@ -0,0 +1,152 @@ +#include "tools/unit-test/slang-unit-test.h" + +#include "slang-gfx.h" +#include "gfx-test-util.h" +#include "tools/gfx-util/shader-cursor.h" +#include "source/core/slang-basic.h" +#include "source/core/slang-blob.h" + +using namespace gfx; + +namespace gfx_test +{ + // In this test, + // we will run a compute shader that compiles to HLSL with a reference to the macro "DOWNSTREAM_VALUE" + // that will be provided to dxc through slang's link-time compiler options. + // The test verifies that `IComponentType2::linkWithOptions()` is able to produce a linked IComponentType + // with additional compiler options. Here we will specify a DownstreamArg compiler option to define + // the value of DOWNSTREAM_VALUE when running dxc. + // + static Slang::Result loadProgram( + gfx::IDevice* device, + Slang::ComPtr<gfx::IShaderProgram>& outShaderProgram, + const char* shaderModuleName, + const char* entryPointName, + slang::ProgramLayout*& slangReflection) + { + Slang::ComPtr<slang::ISession> slangSession; + SLANG_RETURN_ON_FAIL(device->getSlangSession(slangSession.writeRef())); + Slang::ComPtr<slang::IBlob> diagnosticsBlob; + slang::IModule* module = slangSession->loadModule(shaderModuleName, diagnosticsBlob.writeRef()); + diagnoseIfNeeded(diagnosticsBlob); + if (!module) + return SLANG_FAIL; + + ComPtr<slang::IEntryPoint> computeEntryPoint; + SLANG_RETURN_ON_FAIL( + module->findEntryPointByName(entryPointName, computeEntryPoint.writeRef())); + + Slang::List<slang::IComponentType*> componentTypes; + componentTypes.add(module); + componentTypes.add(computeEntryPoint); + + Slang::ComPtr<slang::IComponentType> composedProgram; + SlangResult result = slangSession->createCompositeComponentType( + componentTypes.getBuffer(), + componentTypes.getCount(), + composedProgram.writeRef(), + diagnosticsBlob.writeRef()); + diagnoseIfNeeded(diagnosticsBlob); + SLANG_RETURN_ON_FAIL(result); + + ComPtr<slang::IComponentType> linkedProgram; + slang::CompilerOptionEntry entry; + entry.name = slang::CompilerOptionName::DownstreamArgs; + entry.value.kind = slang::CompilerOptionValueKind::String; + entry.value.stringValue0 = "dxc"; + entry.value.stringValue1 = "-DDOWNSTREAM_VALUE=4.0"; + result = composedProgram->linkWithOptions(linkedProgram.writeRef(), 1, &entry, diagnosticsBlob.writeRef()); + diagnoseIfNeeded(diagnosticsBlob); + SLANG_RETURN_ON_FAIL(result); + + composedProgram = linkedProgram; + slangReflection = composedProgram->getLayout(); + + gfx::IShaderProgram::Desc programDesc = {}; + programDesc.slangGlobalScope = composedProgram.get(); + + auto shaderProgram = device->createProgram(programDesc); + + outShaderProgram = shaderProgram; + return SLANG_OK; + } + + void linkTimeOptionTestImpl(IDevice* device, UnitTestContext* context) + { + Slang::ComPtr<ITransientResourceHeap> transientHeap; + ITransientResourceHeap::Desc transientHeapDesc = {}; + transientHeapDesc.constantBufferSize = 4096; + GFX_CHECK_CALL_ABORT( + device->createTransientResourceHeap(transientHeapDesc, transientHeap.writeRef())); + + ComPtr<IShaderProgram> shaderProgram; + slang::ProgramLayout* slangReflection; + GFX_CHECK_CALL_ABORT(loadProgram(device, shaderProgram, "link-time-options", "computeMain", slangReflection)); + + ComputePipelineStateDesc pipelineDesc = {}; + pipelineDesc.program = shaderProgram.get(); + ComPtr<gfx::IPipelineState> pipelineState; + GFX_CHECK_CALL_ABORT( + device->createComputePipelineState(pipelineDesc, pipelineState.writeRef())); + + const int numberCount = 4; + float initialData[] = { 0.0f, 0.0f, 0.0f, 0.0f }; + IBufferResource::Desc bufferDesc = {}; + bufferDesc.sizeInBytes = numberCount * sizeof(float); + bufferDesc.format = gfx::Format::Unknown; + bufferDesc.elementSize = sizeof(float); + bufferDesc.allowedStates = ResourceStateSet( + ResourceState::ShaderResource, + ResourceState::UnorderedAccess, + ResourceState::CopyDestination, + ResourceState::CopySource); + bufferDesc.defaultState = ResourceState::UnorderedAccess; + bufferDesc.memoryType = MemoryType::DeviceLocal; + + ComPtr<IBufferResource> numbersBuffer; + GFX_CHECK_CALL_ABORT(device->createBufferResource( + bufferDesc, + (void*)initialData, + numbersBuffer.writeRef())); + + ComPtr<IResourceView> bufferView; + IResourceView::Desc viewDesc = {}; + viewDesc.type = IResourceView::Type::UnorderedAccess; + viewDesc.format = Format::Unknown; + GFX_CHECK_CALL_ABORT( + device->createBufferView(numbersBuffer, nullptr, viewDesc, bufferView.writeRef())); + + // We have done all the set up work, now it is time to start recording a command buffer for + // GPU execution. + { + ICommandQueue::Desc queueDesc = { ICommandQueue::QueueType::Graphics }; + auto queue = device->createCommandQueue(queueDesc); + + auto commandBuffer = transientHeap->createCommandBuffer(); + auto encoder = commandBuffer->encodeComputeCommands(); + + auto rootObject = encoder->bindPipeline(pipelineState); + + ShaderCursor entryPointCursor( + rootObject->getEntryPoint(0)); // get a cursor the the first entry-point. + // Bind buffer view to the entry point. + entryPointCursor.getPath("buffer").setResource(bufferView); + + encoder->dispatchCompute(1, 1, 1); + encoder->endEncoding(); + commandBuffer->close(); + queue->executeCommandBuffer(commandBuffer); + queue->waitOnHost(); + } + + compareComputeResult( + device, + numbersBuffer, + Slang::makeArray<float>(4.0)); + } + + SLANG_UNIT_TEST(linkTimeOptionD3D12) + { + runTestImpl(linkTimeOptionTestImpl, unitTestContext, Slang::RenderApiFlag::D3D12); + } +} diff --git a/tools/gfx-unit-test/link-time-options.slang b/tools/gfx-unit-test/link-time-options.slang new file mode 100644 index 000000000..e168c19fe --- /dev/null +++ b/tools/gfx-unit-test/link-time-options.slang @@ -0,0 +1,20 @@ +// link-time-options.slang + +// Test that we can pass in additional compiler options +// at link time. + +// Lowers to `DOWNSTREAM_VALUE`, a macro that we will define +// for downstream compilation through link-time options. +float getMacroDefinedForDownstream() +{ + __intrinsic_asm "(DOWNSTREAM_VALUE)"; +} + +[shader("compute")] +[numthreads(4,1,1)] +void computeMain( + uint3 sv_dispatchThreadID : SV_DispatchThreadID, + uniform RWStructuredBuffer<float> buffer) +{ + buffer[sv_dispatchThreadID.x] = getMacroDefinedForDownstream(); +} diff --git a/tools/gfx/cpu/cpu-device.cpp b/tools/gfx/cpu/cpu-device.cpp index 4b8595e82..f248cf52a 100644 --- a/tools/gfx/cpu/cpu-device.cpp +++ b/tools/gfx/cpu/cpu-device.cpp @@ -106,10 +106,11 @@ namespace cpu } Result DeviceImpl::createShaderObjectLayout( + slang::ISession* session, slang::TypeLayoutReflection* typeLayout, ShaderObjectLayoutBase** outLayout) { - RefPtr<ShaderObjectLayoutImpl> cpuLayout = new ShaderObjectLayoutImpl(this, typeLayout); + RefPtr<ShaderObjectLayoutImpl> cpuLayout = new ShaderObjectLayoutImpl(this, session, typeLayout); returnRefPtrMove(outLayout, cpuLayout); return SLANG_OK; @@ -166,7 +167,7 @@ namespace cpu if (!slangProgramLayout) return SLANG_FAIL; - RefPtr<RootShaderObjectLayoutImpl> cpuProgramLayout = new RootShaderObjectLayoutImpl(this, slangProgramLayout); + RefPtr<RootShaderObjectLayoutImpl> cpuProgramLayout = new RootShaderObjectLayoutImpl(this, slangGlobalScope->getSession(), slangProgramLayout); cpuProgramLayout->m_programLayout = slangProgramLayout; cpuProgram->layout = cpuProgramLayout; diff --git a/tools/gfx/cpu/cpu-device.h b/tools/gfx/cpu/cpu-device.h index d90ce1e8b..c7b80e26d 100644 --- a/tools/gfx/cpu/cpu-device.h +++ b/tools/gfx/cpu/cpu-device.h @@ -39,6 +39,7 @@ public: IResourceView** outView) override; virtual Result createShaderObjectLayout( + slang::ISession* session, slang::TypeLayoutReflection* typeLayout, ShaderObjectLayoutBase** outLayout) override; diff --git a/tools/gfx/cpu/cpu-shader-object-layout.cpp b/tools/gfx/cpu/cpu-shader-object-layout.cpp index 2ff89efff..4f4c33a6a 100644 --- a/tools/gfx/cpu/cpu-shader-object-layout.cpp +++ b/tools/gfx/cpu/cpu-shader-object-layout.cpp @@ -8,13 +8,13 @@ using namespace Slang; namespace cpu { -ShaderObjectLayoutImpl::ShaderObjectLayoutImpl(RendererBase* renderer, slang::TypeLayoutReflection* layout) +ShaderObjectLayoutImpl::ShaderObjectLayoutImpl(RendererBase* renderer, slang::ISession* session, slang::TypeLayoutReflection* layout) { - initBase(renderer, layout); + initBase(renderer, session, layout); m_subObjectCount = 0; m_resourceCount = 0; - + m_elementTypeLayout = _unwrapParameterGroups(layout, m_containerType); m_size = m_elementTypeLayout->getSize(); @@ -104,7 +104,7 @@ ShaderObjectLayoutImpl::ShaderObjectLayoutImpl(RendererBase* renderer, slang::Ty if (slangBindingType != slang::BindingType::ExistentialValue) { subObjectLayout = - new ShaderObjectLayoutImpl(renderer, slangLeafTypeLayout->getElementTypeLayout()); + new ShaderObjectLayoutImpl(renderer, m_slangSession, slangLeafTypeLayout->getElementTypeLayout()); } SubObjectRangeInfo subObjectRange; @@ -130,14 +130,15 @@ const char* EntryPointLayoutImpl::getEntryPointName() return m_entryPointLayout->getName(); } -RootShaderObjectLayoutImpl::RootShaderObjectLayoutImpl(RendererBase* renderer, slang::ProgramLayout* programLayout) - : ShaderObjectLayoutImpl(renderer, programLayout->getGlobalParamsTypeLayout()) +RootShaderObjectLayoutImpl::RootShaderObjectLayoutImpl(RendererBase* renderer, slang::ISession* session, slang::ProgramLayout* programLayout) + : ShaderObjectLayoutImpl(renderer, session, programLayout->getGlobalParamsTypeLayout()) , m_programLayout(programLayout) { for (UInt i =0; i< programLayout->getEntryPointCount(); i++) { m_entryPointLayouts.add(new EntryPointLayoutImpl( renderer, + session, programLayout->getEntryPointByIndex(i))); } diff --git a/tools/gfx/cpu/cpu-shader-object-layout.h b/tools/gfx/cpu/cpu-shader-object-layout.h index e421918f1..3bf2e2aa7 100644 --- a/tools/gfx/cpu/cpu-shader-object-layout.h +++ b/tools/gfx/cpu/cpu-shader-object-layout.h @@ -55,7 +55,7 @@ public: Index m_subObjectCount = 0; Index m_resourceCount = 0; - ShaderObjectLayoutImpl(RendererBase* renderer, slang::TypeLayoutReflection* layout); + ShaderObjectLayoutImpl(RendererBase* renderer, slang::ISession* session, slang::TypeLayoutReflection* layout); size_t getSize(); Index getResourceCount() const; @@ -73,8 +73,9 @@ private: public: EntryPointLayoutImpl( RendererBase* renderer, + slang::ISession* session, slang::EntryPointLayout* entryPointLayout) - : ShaderObjectLayoutImpl(renderer, entryPointLayout->getTypeLayout()) + : ShaderObjectLayoutImpl(renderer, session, entryPointLayout->getTypeLayout()) , m_entryPointLayout(entryPointLayout) {} @@ -87,7 +88,7 @@ public: slang::ProgramLayout* m_programLayout = nullptr; List<RefPtr<EntryPointLayoutImpl>> m_entryPointLayouts; - RootShaderObjectLayoutImpl(RendererBase* renderer, slang::ProgramLayout* programLayout); + RootShaderObjectLayoutImpl(RendererBase* renderer, slang::ISession* session, slang::ProgramLayout* programLayout); int getKernelIndex(UnownedStringSlice kernelName); void getKernelThreadGroupSize(int kernelIndex, UInt* threadGroupSizes); diff --git a/tools/gfx/cuda/cuda-device.cpp b/tools/gfx/cuda/cuda-device.cpp index 7f931afa1..377a5aba2 100644 --- a/tools/gfx/cuda/cuda-device.cpp +++ b/tools/gfx/cuda/cuda-device.cpp @@ -908,11 +908,12 @@ SLANG_NO_THROW Result SLANG_MCALL DeviceImpl::createQueryPool( } Result DeviceImpl::createShaderObjectLayout( + slang::ISession* session, slang::TypeLayoutReflection* typeLayout, ShaderObjectLayoutBase** outLayout) { RefPtr<ShaderObjectLayoutImpl> cudaLayout; - cudaLayout = new ShaderObjectLayoutImpl(this, typeLayout); + cudaLayout = new ShaderObjectLayoutImpl(this, session, typeLayout); returnRefPtrMove(outLayout, cudaLayout); return SLANG_OK; } diff --git a/tools/gfx/cuda/cuda-device.h b/tools/gfx/cuda/cuda-device.h index bfaf1be6e..e711dc261 100644 --- a/tools/gfx/cuda/cuda-device.h +++ b/tools/gfx/cuda/cuda-device.h @@ -73,6 +73,7 @@ public: IQueryPool** outPool) override; virtual Result createShaderObjectLayout( + slang::ISession* session, slang::TypeLayoutReflection* typeLayout, ShaderObjectLayoutBase** outLayout) override; diff --git a/tools/gfx/cuda/cuda-shader-object-layout.cpp b/tools/gfx/cuda/cuda-shader-object-layout.cpp index eacae0fc0..f527d78de 100644 --- a/tools/gfx/cuda/cuda-shader-object-layout.cpp +++ b/tools/gfx/cuda/cuda-shader-object-layout.cpp @@ -9,11 +9,11 @@ using namespace Slang; namespace cuda { -ShaderObjectLayoutImpl::ShaderObjectLayoutImpl(RendererBase* renderer, slang::TypeLayoutReflection* layout) +ShaderObjectLayoutImpl::ShaderObjectLayoutImpl(RendererBase* renderer, slang::ISession* session, slang::TypeLayoutReflection* layout) { m_elementTypeLayout = _unwrapParameterGroups(layout, m_containerType); - initBase(renderer, m_elementTypeLayout); + initBase(renderer, session, m_elementTypeLayout); // Compute the binding ranges that are used to store // the logical contents of the object in memory. These will relate @@ -101,7 +101,7 @@ ShaderObjectLayoutImpl::ShaderObjectLayoutImpl(RendererBase* renderer, slang::Ty if (slangBindingType != slang::BindingType::ExistentialValue) { subObjectLayout = - new ShaderObjectLayoutImpl(renderer, slangLeafTypeLayout->getElementTypeLayout()); + new ShaderObjectLayoutImpl(renderer, session, slangLeafTypeLayout->getElementTypeLayout()); } SubObjectRangeInfo subObjectRange; @@ -118,13 +118,14 @@ BindingRangeInfo ShaderObjectLayoutImpl::getBindingRange(Index index) { return m Index ShaderObjectLayoutImpl::getBindingRangeCount() const { return m_bindingRanges.getCount(); } RootShaderObjectLayoutImpl::RootShaderObjectLayoutImpl(RendererBase* renderer, slang::ProgramLayout* inProgramLayout) - : ShaderObjectLayoutImpl(renderer, inProgramLayout->getGlobalParamsTypeLayout()) + : ShaderObjectLayoutImpl(renderer, inProgramLayout->getSession(), inProgramLayout->getGlobalParamsTypeLayout()) , programLayout(inProgramLayout) { for (UInt i = 0; i < programLayout->getEntryPointCount(); i++) { entryPointLayouts.add(new ShaderObjectLayoutImpl( renderer, + programLayout->getSession(), programLayout->getEntryPointByIndex(i)->getTypeLayout())); } diff --git a/tools/gfx/cuda/cuda-shader-object-layout.h b/tools/gfx/cuda/cuda-shader-object-layout.h index 5d3a2d52a..edec0c352 100644 --- a/tools/gfx/cuda/cuda-shader-object-layout.h +++ b/tools/gfx/cuda/cuda-shader-object-layout.h @@ -50,7 +50,7 @@ public: Index m_subObjectCount = 0; Index m_resourceCount = 0; - ShaderObjectLayoutImpl(RendererBase* renderer, slang::TypeLayoutReflection* layout); + ShaderObjectLayoutImpl(RendererBase* renderer, slang::ISession* session, slang::TypeLayoutReflection* layout); Index getResourceCount() const; Index getSubObjectCount() const; diff --git a/tools/gfx/d3d11/d3d11-device.cpp b/tools/gfx/d3d11/d3d11-device.cpp index 96a5043fb..20e17b082 100644 --- a/tools/gfx/d3d11/d3d11-device.cpp +++ b/tools/gfx/d3d11/d3d11-device.cpp @@ -1413,12 +1413,13 @@ Result DeviceImpl::createProgram( } Result DeviceImpl::createShaderObjectLayout( + slang::ISession* session, slang::TypeLayoutReflection* typeLayout, ShaderObjectLayoutBase** outLayout) { RefPtr<ShaderObjectLayoutImpl> layout; SLANG_RETURN_ON_FAIL(ShaderObjectLayoutImpl::createForElementType( - this, typeLayout, layout.writeRef())); + this, session, typeLayout, layout.writeRef())); returnRefPtrMove(outLayout, layout); return SLANG_OK; } diff --git a/tools/gfx/d3d11/d3d11-device.h b/tools/gfx/d3d11/d3d11-device.h index 608411912..42fffa3c9 100644 --- a/tools/gfx/d3d11/d3d11-device.h +++ b/tools/gfx/d3d11/d3d11-device.h @@ -59,6 +59,7 @@ public: const IQueryPool::Desc& desc, IQueryPool** outPool) override; virtual Result createShaderObjectLayout( + slang::ISession* session, slang::TypeLayoutReflection* typeLayout, ShaderObjectLayoutBase** outLayout) override; virtual Result createShaderObject(ShaderObjectLayoutBase* layout, IShaderObject** outObject) diff --git a/tools/gfx/d3d11/d3d11-shader-object-layout.cpp b/tools/gfx/d3d11/d3d11-shader-object-layout.cpp index 8032719b0..70204e4c0 100644 --- a/tools/gfx/d3d11/d3d11-shader-object-layout.cpp +++ b/tools/gfx/d3d11/d3d11-shader-object-layout.cpp @@ -180,6 +180,7 @@ Result ShaderObjectLayoutImpl::Builder::setElementTypeLayout(slang::TypeLayoutRe auto elementTypeLayout = slangLeafTypeLayout->getElementTypeLayout(); createForElementType( m_renderer, + m_session, elementTypeLayout, subObjectLayout.writeRef()); } @@ -198,6 +199,7 @@ Result ShaderObjectLayoutImpl::Builder::setElementTypeLayout(slang::TypeLayoutRe { createForElementType( m_renderer, + m_session, pendingTypeLayout, subObjectLayout.writeRef()); @@ -233,10 +235,11 @@ SlangResult ShaderObjectLayoutImpl::Builder::build(ShaderObjectLayoutImpl** outL Result ShaderObjectLayoutImpl::createForElementType( RendererBase* renderer, + slang::ISession* session, slang::TypeLayoutReflection* elementType, ShaderObjectLayoutImpl** outLayout) { - Builder builder(renderer); + Builder builder(renderer, session); builder.setElementTypeLayout(elementType); return builder.build(outLayout); } @@ -245,7 +248,7 @@ Result ShaderObjectLayoutImpl::_init(Builder const* builder) { auto renderer = builder->m_renderer; - initBase(renderer, builder->m_elementTypeLayout); + initBase(renderer, builder->m_session, builder->m_elementTypeLayout); m_bindingRanges = builder->m_bindingRanges; m_srvRanges = builder->m_srvRanges; @@ -303,7 +306,7 @@ Result RootShaderObjectLayoutImpl::create( auto slangEntryPoint = programLayout->getEntryPointByIndex(e); RefPtr<ShaderObjectLayoutImpl> entryPointLayout; SLANG_RETURN_ON_FAIL(ShaderObjectLayoutImpl::createForElementType( - renderer, slangEntryPoint->getTypeLayout(), entryPointLayout.writeRef())); + renderer, program->getSession(), slangEntryPoint->getTypeLayout(), entryPointLayout.writeRef())); builder.addEntryPoint(slangEntryPoint->getStage(), entryPointLayout, slangEntryPoint); } @@ -322,6 +325,8 @@ Result RootShaderObjectLayoutImpl::_init(Builder const* builder) m_programLayout = builder->m_programLayout; m_entryPoints = builder->m_entryPoints; m_pendingDataOffset = builder->m_pendingDataOffset; + m_slangSession = m_program->getSession(); + return SLANG_OK; } diff --git a/tools/gfx/d3d11/d3d11-shader-object-layout.h b/tools/gfx/d3d11/d3d11-shader-object-layout.h index e029a7b76..e18c91c2e 100644 --- a/tools/gfx/d3d11/d3d11-shader-object-layout.h +++ b/tools/gfx/d3d11/d3d11-shader-object-layout.h @@ -107,11 +107,12 @@ public: struct Builder { public: - Builder(RendererBase* renderer) - : m_renderer(renderer) + Builder(RendererBase* renderer, slang::ISession* session) + : m_renderer(renderer), m_session(session) {} RendererBase* m_renderer; + slang::ISession* m_session; slang::TypeLayoutReflection* m_elementTypeLayout; List<BindingRangeInfo> m_bindingRanges; @@ -144,6 +145,7 @@ public: static Result createForElementType( RendererBase* renderer, + slang::ISession* session, slang::TypeLayoutReflection* elementType, ShaderObjectLayoutImpl** outLayout); @@ -216,7 +218,7 @@ public: RendererBase* renderer, slang::IComponentType* program, slang::ProgramLayout* programLayout) - : Super::Builder(renderer) + : Super::Builder(renderer, program->getSession()) , m_program(program) , m_programLayout(programLayout) {} diff --git a/tools/gfx/d3d11/d3d11-shader-object.cpp b/tools/gfx/d3d11/d3d11-shader-object.cpp index 285cc60b6..40d671843 100644 --- a/tools/gfx/d3d11/d3d11-shader-object.cpp +++ b/tools/gfx/d3d11/d3d11-shader-object.cpp @@ -495,6 +495,7 @@ Result ShaderObjectImpl::_createSpecializedLayout(ShaderObjectLayoutImpl** outLa auto renderer = getRenderer(); RefPtr<ShaderObjectLayoutImpl> layout; SLANG_RETURN_ON_FAIL(renderer->getShaderObjectLayout( + m_layout->m_slangSession, extendedType.slangType, m_layout->getContainerType(), (ShaderObjectLayoutBase**)layout.writeRef())); diff --git a/tools/gfx/d3d12/d3d12-device.cpp b/tools/gfx/d3d12/d3d12-device.cpp index cd4dfb7a3..bbf27b4f7 100644 --- a/tools/gfx/d3d12/d3d12-device.cpp +++ b/tools/gfx/d3d12/d3d12-device.cpp @@ -2034,11 +2034,13 @@ Result DeviceImpl::createProgram( } Result DeviceImpl::createShaderObjectLayout( - slang::TypeLayoutReflection* typeLayout, ShaderObjectLayoutBase** outLayout) + slang::ISession* session, + slang::TypeLayoutReflection* typeLayout, + ShaderObjectLayoutBase** outLayout) { RefPtr<ShaderObjectLayoutImpl> layout; SLANG_RETURN_ON_FAIL( - ShaderObjectLayoutImpl::createForElementType(this, typeLayout, layout.writeRef())); + ShaderObjectLayoutImpl::createForElementType(this, session, typeLayout, layout.writeRef())); returnRefPtrMove(outLayout, layout); return SLANG_OK; } diff --git a/tools/gfx/d3d12/d3d12-device.h b/tools/gfx/d3d12/d3d12-device.h index 6bbdde9d0..a38e3c68e 100644 --- a/tools/gfx/d3d12/d3d12-device.h +++ b/tools/gfx/d3d12/d3d12-device.h @@ -152,7 +152,7 @@ public: createInputLayout(IInputLayout::Desc const& desc, IInputLayout** outLayout) override; virtual Result createShaderObjectLayout( - slang::TypeLayoutReflection* typeLayout, ShaderObjectLayoutBase** outLayout) override; + slang::ISession* session, slang::TypeLayoutReflection* typeLayout, ShaderObjectLayoutBase** outLayout) override; virtual Result createShaderObject( ShaderObjectLayoutBase* layout, IShaderObject** outObject) override; virtual Result createMutableShaderObject( diff --git a/tools/gfx/d3d12/d3d12-shader-object-layout.cpp b/tools/gfx/d3d12/d3d12-shader-object-layout.cpp index c43d3881e..0c0095621 100644 --- a/tools/gfx/d3d12/d3d12-shader-object-layout.cpp +++ b/tools/gfx/d3d12/d3d12-shader-object-layout.cpp @@ -50,10 +50,11 @@ bool ShaderObjectLayoutImpl::isBindingRangeRootParameter( Result ShaderObjectLayoutImpl::createForElementType( RendererBase* renderer, + slang::ISession* session, slang::TypeLayoutReflection* elementType, ShaderObjectLayoutImpl** outLayout) { - Builder builder(renderer); + Builder builder(renderer, session); builder.setElementTypeLayout(elementType); return builder.build(outLayout); } @@ -62,7 +63,7 @@ Result ShaderObjectLayoutImpl::init(Builder* builder) { auto renderer = builder->m_renderer; - initBase(renderer, builder->m_elementTypeLayout); + initBase(renderer, builder->m_session, builder->m_elementTypeLayout); m_containerType = builder->m_containerType; @@ -223,13 +224,14 @@ Result ShaderObjectLayoutImpl::Builder::setElementTypeLayout( { if (auto pendingTypeLayout = slangLeafTypeLayout->getPendingDataTypeLayout()) { - createForElementType(m_renderer, pendingTypeLayout, subObjectLayout.writeRef()); + createForElementType(m_renderer, m_session, pendingTypeLayout, subObjectLayout.writeRef()); } } else { createForElementType( m_renderer, + m_session, slangLeafTypeLayout->getElementTypeLayout(), subObjectLayout.writeRef()); } @@ -982,7 +984,7 @@ Result RootShaderObjectLayoutImpl::create( auto slangEntryPoint = programLayout->getEntryPointByIndex(e); RefPtr<ShaderObjectLayoutImpl> entryPointLayout; SLANG_RETURN_ON_FAIL(ShaderObjectLayoutImpl::createForElementType( - device, slangEntryPoint->getTypeLayout(), entryPointLayout.writeRef())); + device, program->getSession(), slangEntryPoint->getTypeLayout(), entryPointLayout.writeRef())); builder.addEntryPoint(slangEntryPoint->getStage(), entryPointLayout); } diff --git a/tools/gfx/d3d12/d3d12-shader-object-layout.h b/tools/gfx/d3d12/d3d12-shader-object-layout.h index accd30aa9..4b46df0b0 100644 --- a/tools/gfx/d3d12/d3d12-shader-object-layout.h +++ b/tools/gfx/d3d12/d3d12-shader-object-layout.h @@ -124,11 +124,12 @@ public: struct Builder { public: - Builder(RendererBase* renderer) - : m_renderer(renderer) + Builder(RendererBase* renderer, slang::ISession* session) + : m_renderer(renderer), m_session(session) {} RendererBase* m_renderer; + slang::ISession* m_session; slang::TypeLayoutReflection* m_elementTypeLayout; List<BindingRangeInfo> m_bindingRanges; List<SubObjectRangeInfo> m_subObjectRanges; @@ -165,6 +166,7 @@ public: static Result createForElementType( RendererBase* renderer, + slang::ISession* session, slang::TypeLayoutReflection* elementType, ShaderObjectLayoutImpl** outLayout); @@ -238,7 +240,7 @@ public: RendererBase* renderer, slang::IComponentType* program, slang::ProgramLayout* programLayout) - : Super::Builder(renderer) + : Super::Builder(renderer, program->getSession()) , m_program(program) , m_programLayout(programLayout) {} diff --git a/tools/gfx/d3d12/d3d12-shader-object.cpp b/tools/gfx/d3d12/d3d12-shader-object.cpp index 5227579ce..1b7b51106 100644 --- a/tools/gfx/d3d12/d3d12-shader-object.cpp +++ b/tools/gfx/d3d12/d3d12-shader-object.cpp @@ -868,6 +868,7 @@ Result ShaderObjectImpl::_createSpecializedLayout(ShaderObjectLayoutImpl** outLa auto renderer = getRenderer(); RefPtr<ShaderObjectLayoutImpl> layout; SLANG_RETURN_ON_FAIL(renderer->getShaderObjectLayout( + m_layout->m_slangSession, extendedType.slangType, m_layout->getContainerType(), (ShaderObjectLayoutBase**)layout.writeRef())); diff --git a/tools/gfx/debug-layer/debug-device.cpp b/tools/gfx/debug-layer/debug-device.cpp index 45374b64f..44ca1de7a 100644 --- a/tools/gfx/debug-layer/debug-device.cpp +++ b/tools/gfx/debug-layer/debug-device.cpp @@ -376,6 +376,27 @@ Result DebugDevice::createShaderObject( return result; } +Result DebugDevice::createShaderObject2( + slang::ISession* session, + slang::TypeReflection* type, + ShaderObjectContainerType containerType, + IShaderObject** outShaderObject) +{ + SLANG_GFX_API_FUNC; + + RefPtr<DebugShaderObject> outObject = new DebugShaderObject(); + auto typeName = type->getName(); + auto result = + baseObject->createShaderObject2(session, type, containerType, outObject->baseObject.writeRef()); + outObject->m_typeName = typeName; + outObject->m_device = this; + outObject->m_slangType = type; + if (SLANG_FAILED(result)) + return result; + returnComPtr(outShaderObject, outObject); + return result; +} + Result DebugDevice::createMutableShaderObject( slang::TypeReflection* type, ShaderObjectContainerType containerType, @@ -396,6 +417,27 @@ Result DebugDevice::createMutableShaderObject( return result; } +Result DebugDevice::createMutableShaderObject2( + slang::ISession* session, + slang::TypeReflection* type, + ShaderObjectContainerType containerType, + IShaderObject** outShaderObject) +{ + SLANG_GFX_API_FUNC; + + RefPtr<DebugShaderObject> outObject = new DebugShaderObject(); + auto typeName = type->getName(); + auto result = + baseObject->createMutableShaderObject2(session, type, containerType, outObject->baseObject.writeRef()); + outObject->m_typeName = typeName; + outObject->m_device = this; + outObject->m_slangType = type; + if (SLANG_FAILED(result)) + return result; + returnComPtr(outShaderObject, outObject); + return result; +} + Result DebugDevice::createMutableRootShaderObject( IShaderProgram* program, IShaderObject** outRootObject) { diff --git a/tools/gfx/debug-layer/debug-device.h b/tools/gfx/debug-layer/debug-device.h index 5b8424093..90feaa37e 100644 --- a/tools/gfx/debug-layer/debug-device.h +++ b/tools/gfx/debug-layer/debug-device.h @@ -94,10 +94,20 @@ public: slang::TypeReflection* type, ShaderObjectContainerType container, IShaderObject** outObject) override; + virtual SLANG_NO_THROW Result SLANG_MCALL createShaderObject2( + slang::ISession* session, + slang::TypeReflection* type, + ShaderObjectContainerType container, + IShaderObject** outObject) override; virtual SLANG_NO_THROW Result SLANG_MCALL createMutableShaderObject( slang::TypeReflection* type, ShaderObjectContainerType container, IShaderObject** outObject) override; + virtual SLANG_NO_THROW Result SLANG_MCALL createMutableShaderObject2( + slang::ISession* session, + slang::TypeReflection* type, + ShaderObjectContainerType container, + IShaderObject** outObject) override; virtual SLANG_NO_THROW Result SLANG_MCALL createShaderObjectFromTypeLayout( slang::TypeLayoutReflection* typeLayout, IShaderObject** outObject) override; virtual SLANG_NO_THROW Result SLANG_MCALL createMutableShaderObjectFromTypeLayout( diff --git a/tools/gfx/open-gl/render-gl.cpp b/tools/gfx/open-gl/render-gl.cpp index c9eb1d94d..b5ab14fe8 100644 --- a/tools/gfx/open-gl/render-gl.cpp +++ b/tools/gfx/open-gl/render-gl.cpp @@ -137,6 +137,7 @@ public: IInputLayout** outLayout) override; virtual Result createShaderObjectLayout( + slang::ISession* session, slang::TypeLayoutReflection* typeLayout, ShaderObjectLayoutBase** outLayout) override; virtual Result createShaderObject(ShaderObjectLayoutBase* layout, IShaderObject** outObject) override; @@ -682,11 +683,12 @@ public: struct Builder { public: - Builder(RendererBase* renderer) - : m_renderer(renderer) + Builder(RendererBase* renderer, slang::ISession* session) + : m_renderer(renderer), m_session(session) {} RendererBase* m_renderer; + slang::ISession* m_session; slang::TypeLayoutReflection* m_elementTypeLayout; /// The container type of this shader object. When `m_containerType` is @@ -792,6 +794,7 @@ public: { createForElementType( m_renderer, + m_session, slangLeafTypeLayout->getElementTypeLayout(), subObjectLayout.writeRef()); } @@ -818,10 +821,11 @@ public: static Result createForElementType( RendererBase* renderer, + slang::ISession* session, slang::TypeLayoutReflection* elementType, ShaderObjectLayoutImpl** outLayout) { - Builder builder(renderer); + Builder builder(renderer, session); builder.setElementTypeLayout(elementType); return builder.build(outLayout); } @@ -851,7 +855,7 @@ public: { auto renderer = builder->m_renderer; - initBase(renderer, builder->m_elementTypeLayout); + initBase(renderer, builder->m_session, builder->m_elementTypeLayout); m_bindingRanges = builder->m_bindingRanges; @@ -889,7 +893,7 @@ public: RendererBase* renderer, slang::IComponentType* program, slang::ProgramLayout* programLayout) - : Super::Builder(renderer) + : Super::Builder(renderer, program->getSession()) , m_program(program) , m_programLayout(programLayout) {} @@ -939,7 +943,7 @@ public: auto slangEntryPoint = programLayout->getEntryPointByIndex(e); RefPtr<ShaderObjectLayoutImpl> entryPointLayout; SLANG_RETURN_ON_FAIL(ShaderObjectLayoutImpl::createForElementType( - renderer, slangEntryPoint->getTypeLayout(), entryPointLayout.writeRef())); + renderer, program->getSession(), slangEntryPoint->getTypeLayout(), entryPointLayout.writeRef())); builder.addEntryPoint(slangEntryPoint->getStage(), entryPointLayout); } @@ -1426,6 +1430,7 @@ public: auto renderer = getRenderer(); RefPtr<ShaderObjectLayoutImpl> layout; SLANG_RETURN_ON_FAIL(renderer->getShaderObjectLayout( + m_layout->m_slangSession, extendedType.slangType, m_layout->getContainerType(), (ShaderObjectLayoutBase**)layout.writeRef())); @@ -2898,12 +2903,13 @@ Result GLDevice::createComputePipelineState(const ComputePipelineStateDesc& inDe } Result GLDevice::createShaderObjectLayout( + slang::ISession* session, slang::TypeLayoutReflection* typeLayout, ShaderObjectLayoutBase** outLayout) { RefPtr<ShaderObjectLayoutImpl> layout; SLANG_RETURN_ON_FAIL(ShaderObjectLayoutImpl::createForElementType( - this, typeLayout, layout.writeRef())); + this, session, typeLayout, layout.writeRef())); returnRefPtrMove(outLayout, layout); return SLANG_OK; } diff --git a/tools/gfx/renderer-shared.cpp b/tools/gfx/renderer-shared.cpp index 54311dd47..911d4712c 100644 --- a/tools/gfx/renderer-shared.cpp +++ b/tools/gfx/renderer-shared.cpp @@ -524,8 +524,17 @@ SLANG_NO_THROW Result SLANG_MCALL RendererBase::createShaderObject( ShaderObjectContainerType container, IShaderObject** outObject) { + return createShaderObject2(slangContext.session, type, container, outObject); +} + +SLANG_NO_THROW Result SLANG_MCALL RendererBase::createShaderObject2( + slang::ISession* slangSession, + slang::TypeReflection* type, + ShaderObjectContainerType container, + IShaderObject** outObject) +{ RefPtr<ShaderObjectLayoutBase> shaderObjectLayout; - SLANG_RETURN_ON_FAIL(getShaderObjectLayout(type, container, shaderObjectLayout.writeRef())); + SLANG_RETURN_ON_FAIL(getShaderObjectLayout(slangSession, type, container, shaderObjectLayout.writeRef())); return createShaderObject(shaderObjectLayout, outObject); } @@ -534,8 +543,17 @@ SLANG_NO_THROW Result SLANG_MCALL RendererBase::createMutableShaderObject( ShaderObjectContainerType containerType, IShaderObject** outObject) { + return createMutableShaderObject2(slangContext.session, type, containerType, outObject); +} + +SLANG_NO_THROW Result SLANG_MCALL RendererBase::createMutableShaderObject2( + slang::ISession* slangSession, + slang::TypeReflection* type, + ShaderObjectContainerType containerType, + IShaderObject** outObject) +{ RefPtr<ShaderObjectLayoutBase> shaderObjectLayout; - SLANG_RETURN_ON_FAIL(getShaderObjectLayout(type, containerType, shaderObjectLayout.writeRef())); + SLANG_RETURN_ON_FAIL(getShaderObjectLayout(slangSession, type, containerType, shaderObjectLayout.writeRef())); return createMutableShaderObject(shaderObjectLayout, outObject); } @@ -616,7 +634,7 @@ SLANG_NO_THROW Result SLANG_MCALL RendererBase::createShaderObjectFromTypeLayout slang::TypeLayoutReflection* typeLayout, IShaderObject** outObject) { RefPtr<ShaderObjectLayoutBase> shaderObjectLayout; - SLANG_RETURN_ON_FAIL(getShaderObjectLayout(typeLayout, shaderObjectLayout.writeRef())); + SLANG_RETURN_ON_FAIL(getShaderObjectLayout(slangContext.session, typeLayout, shaderObjectLayout.writeRef())); return createShaderObject(shaderObjectLayout, outObject); } @@ -624,7 +642,7 @@ SLANG_NO_THROW Result SLANG_MCALL RendererBase::createMutableShaderObjectFromTyp slang::TypeLayoutReflection* typeLayout, IShaderObject** outObject) { RefPtr<ShaderObjectLayoutBase> shaderObjectLayout; - SLANG_RETURN_ON_FAIL(getShaderObjectLayout(typeLayout, shaderObjectLayout.writeRef())); + SLANG_RETURN_ON_FAIL(getShaderObjectLayout(slangContext.session, typeLayout, shaderObjectLayout.writeRef())); return createMutableShaderObject(shaderObjectLayout, outObject); } @@ -702,6 +720,7 @@ Result RendererBase::getTextureRowAlignment(Size* outAlignment) } Result RendererBase::getShaderObjectLayout( + slang::ISession* session, slang::TypeReflection* type, ShaderObjectContainerType container, ShaderObjectLayoutBase** outLayout) @@ -709,26 +728,30 @@ Result RendererBase::getShaderObjectLayout( switch (container) { case ShaderObjectContainerType::StructuredBuffer: - type = slangContext.session->getContainerType(type, slang::ContainerType::StructuredBuffer); + type = session->getContainerType(type, slang::ContainerType::StructuredBuffer); break; case ShaderObjectContainerType::Array: - type = slangContext.session->getContainerType(type, slang::ContainerType::UnsizedArray); + type = session->getContainerType(type, slang::ContainerType::UnsizedArray); break; default: break; } - auto typeLayout = slangContext.session->getTypeLayout(type); - return getShaderObjectLayout(typeLayout, outLayout); + auto typeLayout = session->getTypeLayout(type); + SLANG_RETURN_ON_FAIL(getShaderObjectLayout(session, typeLayout, outLayout)); + (*outLayout)->m_slangSession = session; + return SLANG_OK; } Result RendererBase::getShaderObjectLayout( - slang::TypeLayoutReflection* typeLayout, ShaderObjectLayoutBase** outLayout) + slang::ISession* session, + slang::TypeLayoutReflection* typeLayout, + ShaderObjectLayoutBase** outLayout) { RefPtr<ShaderObjectLayoutBase> shaderObjectLayout; if (!m_shaderObjectLayoutCache.tryGetValue(typeLayout, shaderObjectLayout)) { - SLANG_RETURN_ON_FAIL(createShaderObjectLayout(typeLayout, shaderObjectLayout.writeRef())); + SLANG_RETURN_ON_FAIL(createShaderObjectLayout(session, typeLayout, shaderObjectLayout.writeRef())); m_shaderObjectLayoutCache.add(typeLayout, shaderObjectLayout); } *outLayout = shaderObjectLayout.detach(); @@ -830,9 +853,10 @@ void ShaderCache::addSpecializedPipeline(PipelineKey key, Slang::RefPtr<Pipeline specializedPipelines[key] = specializedPipeline; } -void ShaderObjectLayoutBase::initBase(RendererBase* renderer, slang::TypeLayoutReflection* elementTypeLayout) +void ShaderObjectLayoutBase::initBase(RendererBase* renderer, slang::ISession* session, slang::TypeLayoutReflection* elementTypeLayout) { m_renderer = renderer; + m_slangSession = session; m_elementTypeLayout = elementTypeLayout; m_componentID = m_renderer->shaderCache.getComponentId(m_elementTypeLayout->getType()); } @@ -887,15 +911,12 @@ Result ShaderObjectBase::setExistentialHeader( // Slang runtime, so we can look up the ID for this particular conformance (which // will create it on demand). // - ComPtr<slang::ISession> slangSession; - SLANG_RETURN_ON_FAIL(getRenderer()->getSlangSession(slangSession.writeRef())); - // // Note: If the type doesn't actually conform to the required interface for // this sub-object range, then this is the point where we will detect that // fact and error out. // uint32_t conformanceID = 0xFFFFFFFF; - SLANG_RETURN_ON_FAIL(slangSession->getTypeConformanceWitnessSequentialID( + SLANG_RETURN_ON_FAIL(getLayoutBase()->m_slangSession->getTypeConformanceWitnessSequentialID( concreteType, existentialType, &conformanceID)); // // Once we have the conformance ID, then we can write it into the object diff --git a/tools/gfx/renderer-shared.h b/tools/gfx/renderer-shared.h index 5c67de885..4d88f945b 100644 --- a/tools/gfx/renderer-shared.h +++ b/tools/gfx/renderer-shared.h @@ -390,6 +390,8 @@ protected: ShaderObjectContainerType m_containerType = ShaderObjectContainerType::None; public: + ComPtr<slang::ISession> m_slangSession; + ShaderObjectContainerType getContainerType() { return m_containerType; } static slang::TypeLayoutReflection* _unwrapParameterGroups( @@ -444,7 +446,7 @@ public: return m_componentID; } - void initBase(RendererBase* renderer, slang::TypeLayoutReflection* elementTypeLayout); + void initBase(RendererBase* renderer, slang::ISession* session, slang::TypeLayoutReflection* elementTypeLayout); }; class SimpleShaderObjectData @@ -495,7 +497,6 @@ protected: // The specialized shader object type. ExtendedShaderObjectType shaderObjectType = { nullptr, kInvalidComponentID }; - Result _getSpecializedShaderObjectType(ExtendedShaderObjectType* outType); slang::TypeLayoutReflection* _getElementTypeLayout() { @@ -1265,11 +1266,23 @@ public: ShaderObjectContainerType containerType, IShaderObject** outObject) SLANG_OVERRIDE; + virtual SLANG_NO_THROW Result SLANG_MCALL createShaderObject2( + slang::ISession* session, + slang::TypeReflection* type, + ShaderObjectContainerType containerType, + IShaderObject** outObject) SLANG_OVERRIDE; + virtual SLANG_NO_THROW Result SLANG_MCALL createMutableShaderObject( slang::TypeReflection* type, ShaderObjectContainerType containerType, IShaderObject** outObject) SLANG_OVERRIDE; + virtual SLANG_NO_THROW Result SLANG_MCALL createMutableShaderObject2( + slang::ISession* session, + slang::TypeReflection* type, + ShaderObjectContainerType containerType, + IShaderObject** outObject) SLANG_OVERRIDE; + virtual SLANG_NO_THROW Result SLANG_MCALL createShaderObjectFromTypeLayout( slang::TypeLayoutReflection* typeLayout, IShaderObject** outObject) override; @@ -1325,11 +1338,13 @@ public: slang::IBlob** outDiagnostics = nullptr); Result getShaderObjectLayout( + slang::ISession* session, slang::TypeReflection* type, ShaderObjectContainerType container, ShaderObjectLayoutBase** outLayout); Result getShaderObjectLayout( + slang::ISession* session, slang::TypeLayoutReflection* typeLayout, ShaderObjectLayoutBase** outLayout); @@ -1345,6 +1360,7 @@ public: virtual Result createShaderObjectLayout( + slang::ISession* session, slang::TypeLayoutReflection* typeLayout, ShaderObjectLayoutBase** outLayout) = 0; diff --git a/tools/gfx/slang.slang b/tools/gfx/slang.slang index 4e2700c2c..26ad7dce0 100644 --- a/tools/gfx/slang.slang +++ b/tools/gfx/slang.slang @@ -331,17 +331,7 @@ public struct TargetDesc public enum SessionFlags { - kSessionFlags_None = 0, - - /** Use application-specific policy for semantics of the `shared` keyword. - - This is a legacy/compatibility flag to help an existing Slang client - migrate to new language features, and should *not* be used by other - clients. This feature may be removed in a future release without a - deprecation warning, and this bit may be re-used for another feature. - You have been warned. - */ - kSessionFlag_FalcorCustomSharedKeywordSemantics = 1 << 0, + kSessionFlags_None = 0 }; public struct PreprocessorMacroDesc diff --git a/tools/gfx/vulkan/vk-device.cpp b/tools/gfx/vulkan/vk-device.cpp index 4f2899f1b..e1b1eaf27 100644 --- a/tools/gfx/vulkan/vk-device.cpp +++ b/tools/gfx/vulkan/vk-device.cpp @@ -2168,11 +2168,13 @@ Result DeviceImpl::createProgram( } Result DeviceImpl::createShaderObjectLayout( - slang::TypeLayoutReflection* typeLayout, ShaderObjectLayoutBase** outLayout) + slang::ISession* session, + slang::TypeLayoutReflection* typeLayout, + ShaderObjectLayoutBase** outLayout) { RefPtr<ShaderObjectLayoutImpl> layout; SLANG_RETURN_ON_FAIL( - ShaderObjectLayoutImpl::createForElementType(this, typeLayout, layout.writeRef())); + ShaderObjectLayoutImpl::createForElementType(this, session, typeLayout, layout.writeRef())); returnRefPtrMove(outLayout, layout); return SLANG_OK; } diff --git a/tools/gfx/vulkan/vk-device.h b/tools/gfx/vulkan/vk-device.h index 9731fd1d4..89c7aa103 100644 --- a/tools/gfx/vulkan/vk-device.h +++ b/tools/gfx/vulkan/vk-device.h @@ -66,7 +66,9 @@ public: createInputLayout(IInputLayout::Desc const& desc, IInputLayout** outLayout) override; virtual Result createShaderObjectLayout( - slang::TypeLayoutReflection* typeLayout, ShaderObjectLayoutBase** outLayout) override; + slang::ISession* session, + slang::TypeLayoutReflection* typeLayout, + ShaderObjectLayoutBase** outLayout) override; virtual Result createShaderObject( ShaderObjectLayoutBase* layout, IShaderObject** outObject) override; virtual Result createMutableShaderObject( diff --git a/tools/gfx/vulkan/vk-shader-object-layout.cpp b/tools/gfx/vulkan/vk-shader-object-layout.cpp index d7f0d0fd0..d84627e86 100644 --- a/tools/gfx/vulkan/vk-shader-object-layout.cpp +++ b/tools/gfx/vulkan/vk-shader-object-layout.cpp @@ -449,7 +449,7 @@ void ShaderObjectLayoutImpl::Builder::addBindingRanges(slang::TypeLayoutReflecti auto varLayout = slangLeafTypeLayout->getElementVarLayout(); auto subTypeLayout = varLayout->getTypeLayout(); ShaderObjectLayoutImpl::createForElementType( - m_renderer, subTypeLayout, subObjectLayout.writeRef()); + m_renderer, m_session, subTypeLayout, subObjectLayout.writeRef()); } break; @@ -457,7 +457,7 @@ void ShaderObjectLayoutImpl::Builder::addBindingRanges(slang::TypeLayoutReflecti if (auto pendingTypeLayout = slangLeafTypeLayout->getPendingDataTypeLayout()) { ShaderObjectLayoutImpl::createForElementType( - m_renderer, pendingTypeLayout, subObjectLayout.writeRef()); + m_renderer, m_session, pendingTypeLayout, subObjectLayout.writeRef()); } break; } @@ -551,10 +551,11 @@ SlangResult ShaderObjectLayoutImpl::Builder::build(ShaderObjectLayoutImpl** outL Result ShaderObjectLayoutImpl::createForElementType( DeviceImpl* renderer, + slang::ISession* session, slang::TypeLayoutReflection* elementType, ShaderObjectLayoutImpl** outLayout) { - Builder builder(renderer); + Builder builder(renderer, session); builder.setElementTypeLayout(elementType); // When constructing a shader object layout directly from a reflected @@ -618,7 +619,7 @@ Result ShaderObjectLayoutImpl::_init(Builder const* builder) { auto renderer = builder->m_renderer; - initBase(renderer, builder->m_elementTypeLayout); + initBase(renderer, builder->m_session, builder->m_elementTypeLayout); m_bindingRanges = builder->m_bindingRanges; @@ -722,7 +723,7 @@ Result RootShaderObjectLayout::create( { auto slangEntryPoint = programLayout->getEntryPointByIndex(e); - EntryPointLayout::Builder entryPointBuilder(renderer); + EntryPointLayout::Builder entryPointBuilder(renderer, program->getSession()); entryPointBuilder.addEntryPointParams(slangEntryPoint); RefPtr<EntryPointLayout> entryPointLayout; diff --git a/tools/gfx/vulkan/vk-shader-object-layout.h b/tools/gfx/vulkan/vk-shader-object-layout.h index 1d2b08b6c..3f60e6b89 100644 --- a/tools/gfx/vulkan/vk-shader-object-layout.h +++ b/tools/gfx/vulkan/vk-shader-object-layout.h @@ -134,11 +134,12 @@ public: struct Builder { public: - Builder(DeviceImpl* renderer) - : m_renderer(renderer) + Builder(DeviceImpl* renderer, slang::ISession* session) + : m_renderer(renderer), m_session(session) {} DeviceImpl* m_renderer; + slang::ISession* m_session; slang::TypeLayoutReflection* m_elementTypeLayout; /// The container type of this shader object. When `m_containerType` is @@ -214,6 +215,7 @@ public: static Result createForElementType( DeviceImpl* renderer, + slang::ISession* session, slang::TypeLayoutReflection* elementType, ShaderObjectLayoutImpl** outLayout); @@ -321,8 +323,8 @@ class EntryPointLayout : public ShaderObjectLayoutImpl public: struct Builder : Super::Builder { - Builder(DeviceImpl* device) - : Super::Builder(device) + Builder(DeviceImpl* device, slang::ISession* session) + : Super::Builder(device, session) {} Result build(EntryPointLayout** outLayout); @@ -367,7 +369,7 @@ public: DeviceImpl* renderer, slang::IComponentType* program, slang::ProgramLayout* programLayout) - : Super::Builder(renderer) + : Super::Builder(renderer, program->getSession()) , m_program(program) , m_programLayout(programLayout) {} diff --git a/tools/gfx/vulkan/vk-shader-object.cpp b/tools/gfx/vulkan/vk-shader-object.cpp index 31422429b..77707eac0 100644 --- a/tools/gfx/vulkan/vk-shader-object.cpp +++ b/tools/gfx/vulkan/vk-shader-object.cpp @@ -977,6 +977,7 @@ Result ShaderObjectImpl::_createSpecializedLayout(ShaderObjectLayoutImpl** outLa auto device = getDevice(); RefPtr<ShaderObjectLayoutImpl> layout; SLANG_RETURN_ON_FAIL(device->getShaderObjectLayout( + m_layout->m_slangSession, extendedType.slangType, m_layout->getContainerType(), (ShaderObjectLayoutBase**)layout.writeRef())); diff --git a/tools/render-test/options.cpp b/tools/render-test/options.cpp index 4b62eb60b..1d7c3cc2e 100644 --- a/tools/render-test/options.cpp +++ b/tools/render-test/options.cpp @@ -62,7 +62,6 @@ static gfx::DeviceType _toRenderType(Slang::RenderApiType apiType) { args.setArgs(argv, argc); } - SLANG_RETURN_ON_FAIL(outOptions.downstreamArgs.stripDownstreamArgs(args, 0, &sink)); CommandLineReader reader(&args, &sink); diff --git a/tools/render-test/render-test-main.cpp b/tools/render-test/render-test-main.cpp index 1f2b3a5ae..02c0ea86a 100644 --- a/tools/render-test/render-test-main.cpp +++ b/tools/render-test/render-test-main.cpp @@ -153,16 +153,19 @@ protected: struct AssignValsFromLayoutContext { IDevice* device; + slang::ISession* slangSession; ShaderOutputPlan& outputPlan; slang::ProgramLayout* slangReflection; IAccelerationStructure* accelerationStructure; AssignValsFromLayoutContext( IDevice* device, + slang::ISession* slangSession, ShaderOutputPlan& outputPlan, slang::ProgramLayout* slangReflection, IAccelerationStructure* accelerationStructure) : device(device) + , slangSession(slangSession) , outputPlan(outputPlan) , slangReflection(slangReflection) , accelerationStructure(accelerationStructure) @@ -389,7 +392,8 @@ struct AssignValsFromLayoutContext slangType = slangTypeLayout->getType(); } - ComPtr<IShaderObject> shaderObject = device->createShaderObject(slangType); + ComPtr<IShaderObject> shaderObject; + device->createShaderObject2(slangSession, slangType, ShaderObjectContainerType::None, shaderObject.writeRef()); SLANG_RETURN_ON_FAIL(assign(ShaderCursor(shaderObject), srcVal->contentVal)); dstCursor.setObject(shaderObject); @@ -478,15 +482,16 @@ struct AssignValsFromLayoutContext }; SlangResult _assignVarsFromLayout( - IDevice* device, - IShaderObject* shaderObject, + IDevice* device, + slang::ISession* slangSession, + IShaderObject* shaderObject, ShaderInputLayout const& layout, ShaderOutputPlan& ioOutputPlan, slang::ProgramLayout* slangReflection, IAccelerationStructure* accelerationStructure) { AssignValsFromLayoutContext context( - device, ioOutputPlan, slangReflection, accelerationStructure); + device, slangSession, ioOutputPlan, slangReflection, accelerationStructure); ShaderCursor rootCursor = ShaderCursor(shaderObject); return context.assign(rootCursor, layout.rootVal); } @@ -495,6 +500,8 @@ Result RenderTestApp::applyBinding(PipelineType pipelineType, ICommandEncoder* e { auto slangReflection = (slang::ProgramLayout*)spGetReflection( m_compilationOutput.output.getRequestForReflection()); + ComPtr<slang::ISession> slangSession; + m_compilationOutput.output.m_requestForKernels->getSession(slangSession.writeRef()); switch (pipelineType) { @@ -504,6 +511,7 @@ Result RenderTestApp::applyBinding(PipelineType pipelineType, ICommandEncoder* e auto rootObject = computeEncoder->bindPipeline(m_pipelineState); SLANG_RETURN_ON_FAIL(_assignVarsFromLayout( m_device, + slangSession, rootObject, m_compilationOutput.layout, m_outputPlan, @@ -517,6 +525,7 @@ Result RenderTestApp::applyBinding(PipelineType pipelineType, ICommandEncoder* e auto rootObject = renderEncoder->bindPipeline(m_pipelineState); SLANG_RETURN_ON_FAIL(_assignVarsFromLayout( m_device, + slangSession, rootObject, m_compilationOutput.layout, m_outputPlan, @@ -541,7 +550,7 @@ SlangResult RenderTestApp::initialize( // We begin by compiling the shader file and entry points that specified via the options. // - SLANG_RETURN_ON_FAIL(ShaderCompilerUtil::compileWithLayout(device->getSlangSession(), options, input, m_compilationOutput)); + SLANG_RETURN_ON_FAIL(ShaderCompilerUtil::compileWithLayout(device->getSlangSession()->getGlobalSession(), options, input, m_compilationOutput)); m_shaderInputLayout = m_compilationOutput.layout; // Once the shaders have been compiled we load them via the underlying API. @@ -641,7 +650,7 @@ Result RenderTestApp::_initializeShaders( Options::ShaderProgramType shaderType, const ShaderCompilerUtil::Input& input) { - SLANG_RETURN_ON_FAIL(ShaderCompilerUtil::compileWithLayout(device->getSlangSession(), m_options, input, m_compilationOutput)); + SLANG_RETURN_ON_FAIL(ShaderCompilerUtil::compileWithLayout(device->getSlangSession()->getGlobalSession(), m_options, input, m_compilationOutput)); m_shaderInputLayout = m_compilationOutput.layout; m_shaderProgram = device->createProgram(m_compilationOutput.output.desc); return m_shaderProgram ? SLANG_OK : SLANG_FAIL; diff --git a/tools/render-test/slang-support.cpp b/tools/render-test/slang-support.cpp index c598e4ea5..f585abe5b 100644 --- a/tools/render-test/slang-support.cpp +++ b/tools/render-test/slang-support.cpp @@ -71,14 +71,19 @@ void ShaderCompilerUtil::Output::reset() m_extraRequestForReflection = nullptr; } -/* static */ SlangResult ShaderCompilerUtil::_compileProgramImpl(slang::ISession* session, const Options& options, const Input& input, const ShaderCompileRequest& request, Output& out) +/* static */ SlangResult ShaderCompilerUtil::_compileProgramImpl(slang::IGlobalSession* globalSession, const Options& options, const Input& input, const ShaderCompileRequest& request, Output& out) { out.reset(); + slang::SessionDesc sessionDesc = {}; + List<slang::PreprocessorMacroDesc> macros; + sessionDesc.preprocessorMacroCount = (SlangInt)macros.getCount(); + sessionDesc.preprocessorMacros = macros.getBuffer(); + ComPtr<SlangCompileRequest> slangRequest = nullptr; - session->createCompileRequest(slangRequest.writeRef()); + globalSession->createCompileRequest(slangRequest.writeRef()); out.m_requestForKernels = slangRequest; - out.session = session->getGlobalSession(); + out.session = globalSession; // Parse all the extra args { @@ -104,7 +109,6 @@ void ShaderCompilerUtil::Output::reset() } } } - spSetCodeGenTarget(slangRequest, input.target); spSetTargetProfile(slangRequest, 0, spFindProfile(out.session, input.profile.getBuffer())); if (options.generateSPIRVDirectly) @@ -283,11 +287,11 @@ void ShaderCompilerUtil::Output::reset() return SLANG_OK; } -/* static */ SlangResult ShaderCompilerUtil::compileProgram(slang::ISession* session, const Options& options, const Input& input, const ShaderCompileRequest& request, Output& out) +/* static */ SlangResult ShaderCompilerUtil::compileProgram(slang::IGlobalSession* globalSession, const Options& options, const Input& input, const ShaderCompileRequest& request, Output& out) { if( input.passThrough == SLANG_PASS_THROUGH_NONE ) { - return _compileProgramImpl(session, options, input, request, out); + return _compileProgramImpl(globalSession, options, input, request, out); } else { @@ -317,7 +321,7 @@ void ShaderCompilerUtil::Output::reset() // TODO: we want to pass along a flag to skip codegen... - SLANG_RETURN_ON_FAIL(_compileProgramImpl(session, options, slangInput, request, slangOutput)); + SLANG_RETURN_ON_FAIL(_compileProgramImpl(globalSession, options, slangInput, request, slangOutput)); } // Now we have what we need to be able to do the downstream compile better. @@ -326,7 +330,7 @@ void ShaderCompilerUtil::Output::reset() // to fill in the actual entry points to be used for this compilation, // so that discovery of entry points via `[shader(...)]` attributes will work. // - SLANG_RETURN_ON_FAIL(_compileProgramImpl(session, options, input, request, out)); + SLANG_RETURN_ON_FAIL(_compileProgramImpl(globalSession, options, input, request, out)); out.m_extraRequestForReflection = slangOutput.getRequestForReflection(); out.desc.slangGlobalScope = slangOutput.desc.slangGlobalScope; @@ -361,7 +365,11 @@ void ShaderCompilerUtil::Output::reset() return SLANG_OK; } -/* static */SlangResult ShaderCompilerUtil::compileWithLayout(slang::ISession* session, const Options& options, const ShaderCompilerUtil::Input& input, OutputAndLayout& output) +/* static */SlangResult ShaderCompilerUtil::compileWithLayout( + slang::IGlobalSession* globalSession, + const Options& options, + const ShaderCompilerUtil::Input& input, + OutputAndLayout& output) { String sourcePath = options.sourcePath; auto shaderType = options.shaderType; @@ -373,7 +381,7 @@ void ShaderCompilerUtil::Output::reset() { // Add an include of the prelude ComPtr<ISlangBlob> prelude; - session->getGlobalSession()->getLanguagePrelude(input.sourceLanguage, prelude.writeRef()); + globalSession->getLanguagePrelude(input.sourceLanguage, prelude.writeRef()); String preludeString = StringUtil::getString(prelude); @@ -498,7 +506,7 @@ void ShaderCompilerUtil::Output::reset() c.idOverride = conformance.idOverride; compileRequest.typeConformances.add(c); } - return ShaderCompilerUtil::compileProgram(session, options, input, compileRequest, output.output); + return ShaderCompilerUtil::compileProgram(globalSession, options, input, compileRequest, output.output); } } // renderer_test diff --git a/tools/render-test/slang-support.h b/tools/render-test/slang-support.h index 9e06ef77c..6eef93edc 100644 --- a/tools/render-test/slang-support.h +++ b/tools/render-test/slang-support.h @@ -93,12 +93,12 @@ struct ShaderCompilerUtil Slang::String sourcePath; }; - static SlangResult compileWithLayout(slang::ISession* session, const Options& options, const ShaderCompilerUtil::Input& input, OutputAndLayout& output); + static SlangResult compileWithLayout(slang::IGlobalSession* globalSession, const Options& options, const ShaderCompilerUtil::Input& input, OutputAndLayout& output); static SlangResult readSource(const Slang::String& inSourcePath, Slang::List<char>& outSourceText); - static SlangResult _compileProgramImpl(slang::ISession* session, const Options& options, const Input& input, const ShaderCompileRequest& request, Output& out); - static SlangResult compileProgram(slang::ISession* session, const Options& options, const Input& input, const ShaderCompileRequest& request, Output& out); + static SlangResult _compileProgramImpl(slang::IGlobalSession* globalSession, const Options& options, const Input& input, const ShaderCompileRequest& request, Output& out); + static SlangResult compileProgram(slang::IGlobalSession* globalSession, const Options& options, const Input& input, const ShaderCompileRequest& request, Output& out); }; diff --git a/tools/slang-test/slangc-tool.cpp b/tools/slang-test/slangc-tool.cpp index 4c2a3244c..55788d06b 100644 --- a/tools/slang-test/slangc-tool.cpp +++ b/tools/slang-test/slangc-tool.cpp @@ -45,14 +45,7 @@ SlangResult SlangCTool::innerMain(StdWriters* stdWriters, slang::IGlobalSession* compileRequest->setDiagnosticCallback(&_diagnosticCallback, nullptr); compileRequest->setCommandLineCompilerMode(); - { - const SlangResult res = compileRequest->processCommandLineArguments(&argv[1], argc - 1); - if (SLANG_FAILED(res)) - { - StdWriters::getOut().print("%s", compileRequest->getDiagnosticOutput()); - return res; - } - } + SLANG_RETURN_ON_FAIL(compileRequest->processCommandLineArguments(&argv[1], argc - 1)); SlangResult compileRes = SLANG_OK; |