From e68fab2bda5d979f8d991fc41122bb9aa71849a6 Mon Sep 17 00:00:00 2001 From: jsmall-nvidia Date: Tue, 16 Aug 2022 18:19:56 -0400 Subject: IDownstreamCompiler interface (#2361) * WIP with hierarchical enums. * Some small fixes and improvements around artifact desc related types. * Improvements around hierarchical enum. * Fixes to get Artifact types refactor to be able to execute tests. * Attempt to better categorize PTX. * Work around for potentially unused function warning. * Typo fix. * Simplify Artifact header. * Small improvements around Artifact kind/payload/style. * Added IDestroyable/ICastable * Add IArtifactList. * First impl of IArtifactUtil. * Use the ICastable interface for IArtifactRepresentation. * Added IArtifactRepresentation & IArtifactAssociated. * Add SLANG_OVERRIDE to avoid gcc/clang warning. * Fix calling convention issue on win32. * Fix missing SLANG_OVERRIDE. * First attempt at file abstraction around Artifact. * Added creation of lock file. * Move functionality for determining file paths to the IArtifactUtil. Add casting to ICastable. * Added some casting/finding mechanisms. * Simplify IArtifact interface, and use Items for file reps. * Fix problem with libraries on DXIL. * Split out ArtifactRepresentation. * Move ArtifactDesc functionality to ArtifactDescUtil. ArtifactInfoUtil becomes ArtifactDescUtil. * Split implementations from the interfaces for Artifact. * Use TypeTextUtil for target name outputting. * Add artifact impls. * Add ICastableList * Added UnknownCastableAdapter * Make ISlangSharedLibrary derive from ICastable, and remain backwards compatible with slang-llvm. * Refactor Representation on Artifact. * Make our ISlangBlobs also derive from ICastable. Make ISlangBlob atomic ref counted. * Split out CastableList and related types, and placed in core. * Small fixes around IArtifact. Improve IArtifact docs. First impl of getChildren for IArtifact. * Documentation improvements for Artifact related types. * Fix typo. * Special case adding a ICastableList to a LazyCastableList. * Small simplification of LazyCastableList, by adding State member. * Removed the ILockFile interface because IFileArtifactRepresentation can be used. * Implement DiagnosticsArtifactRepresentation. * Added PostEmitMetadataArtifactRepresentation * Add searching by predicate. Added handling of accessing Artifact as ISharedLibrary * Fix typo. * Add find to IArtifacgtList. Fix some missing SLANG_NO_THROW. * Small improvements around ArtifactDesc types. * Another small change around ArtifactKind. * Some more shuffling of ArtifactDesc. * Make IArtifact castable Remove IArtifactList Made IArtifactContainer derive from IArtifact Made ModuleLibrary atomic ref counted/given IModuleLibrary interface. * Must call _requireChildren before any children access. * Fix missing SLANG_MCALL on castAs. * Fix missing SLANG_OVERRIDE. * Added IArtifactHandler * Use ICastable for basis of scope/lookup. * WIP first attempt to remove CompileResult. * Fix support for for downstream compiler shared library adapter. * Fix issues found when replacing CompileResult. * Fix typo. * Fix getting items form 'significant' member of an Artifact. * Split out ArtifactUtil & ArtifactHandler. * Work around for problem on Visual studio. * Improve searching. * Add missing files. * Split out Artifact associated types. Don't produce a container by default - use associated for 'metadata'. * Remove no longer used ArtifactPayload type. * Generalized converting representations. Small improvements to artifacts. * Fix intermediate dumping issue. * Removed #if 0 out CompileResult. Remove DownstreamCompileResult maybeDumpIntermediate. * Pull out functionality for dumping artifact output into ArtifactOutputUtil Fixed a bug in naming files based on ArtifactDesc. * std::atomic issue. * Pull out types from DownstreamCompile to simplify moving to an interface. * Fix typo. * Use IDownstreamCompiler interface. Split out DownstreamCompilerUtil and DownstreamCompilerSet. * Update projects. * Fix missing SLANG_MCALL. * Fix calling convention of IDownstreamCompiler impls. * Split out binary work arounds into a dep1.cpp/h * Small reorganising around DownstreamCompilerInfo. * Remove Desc library functionality to DownstreamCompilerUtil. * Expand IDiagnostics interface. Rename associated impls with Impl suffix. * Fix outputting as text bug. Some small improvements. * Add fix around prefix for dumping. Improved how handling for extensions work form ArtifactDesc. * Dump assembly if available. * Simplify some of Dep1 definitions. --- .../compiler-core/slang-downstream-compiler-util.h | 104 +++++++++++++++++++++ 1 file changed, 104 insertions(+) create mode 100644 source/compiler-core/slang-downstream-compiler-util.h (limited to 'source/compiler-core/slang-downstream-compiler-util.h') diff --git a/source/compiler-core/slang-downstream-compiler-util.h b/source/compiler-core/slang-downstream-compiler-util.h new file mode 100644 index 000000000..9e595bb86 --- /dev/null +++ b/source/compiler-core/slang-downstream-compiler-util.h @@ -0,0 +1,104 @@ +#ifndef SLANG_DOWNSTREAM_COMPILER_UTIL_H +#define SLANG_DOWNSTREAM_COMPILER_UTIL_H + +#include "slang-downstream-compiler.h" +#include "slang-downstream-compiler-set.h" + +namespace Slang +{ + +typedef SlangResult (*DownstreamCompilerLocatorFunc)(const String& path, ISlangSharedLibraryLoader* loader, DownstreamCompilerSet* set); + +struct DownstreamCompilerInfo +{ + typedef DownstreamCompilerInfo This; + typedef uint32_t SourceLanguageFlags; + struct SourceLanguageFlag + { + enum Enum : SourceLanguageFlags + { + Unknown = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_UNKNOWN, + Slang = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_SLANG, + HLSL = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_HLSL, + GLSL = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_GLSL, + C = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_C, + CPP = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_CPP, + CUDA = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_CUDA, + }; + }; + + /// Get info for a compiler type + static const This& getInfo(SlangPassThrough compiler); + /// True if this compiler can compile the specified language + static bool canCompile(SlangPassThrough compiler, SlangSourceLanguage sourceLanguage); + + DownstreamCompilerInfo() : sourceLanguageFlags(0) {} + + DownstreamCompilerInfo(SourceLanguageFlags inSourceLanguageFlags) : + sourceLanguageFlags(inSourceLanguageFlags) + {} + SourceLanguageFlags sourceLanguageFlags; +}; + + +// Combination of a downstream compiler type (pass through) and +// a match version. +struct DownstreamCompilerMatchVersion +{ + DownstreamCompilerMatchVersion(SlangPassThrough inType, MatchSemanticVersion inMatchVersion) : + type(inType), + matchVersion(inMatchVersion) + {} + + DownstreamCompilerMatchVersion() :type(SLANG_PASS_THROUGH_NONE) {} + + SlangPassThrough type; ///< The type of the compiler + MatchSemanticVersion matchVersion; ///< The match version +}; + +struct DownstreamCompilerUtil: public DownstreamCompilerBaseUtil +{ + enum class MatchType + { + MinGreaterEqual, + MinAbsolute, + Newest, + }; + + /// Find a compiler + static IDownstreamCompiler* findCompiler(const DownstreamCompilerSet* set, MatchType matchType, const DownstreamCompilerDesc& desc); + static IDownstreamCompiler* findCompiler(const List& compilers, MatchType matchType, const DownstreamCompilerDesc& desc); + + static IDownstreamCompiler* findCompiler(const List& compilers, SlangPassThrough type, const SemanticVersion& version); + static IDownstreamCompiler* findCompiler(const List& compilers, const DownstreamCompilerDesc& desc); + + /// Find all the compilers with the version + static void findVersions(const List& compilers, SlangPassThrough compiler, List& versions); + + + /// Find the compiler closest to the desc + static IDownstreamCompiler* findClosestCompiler(const List& compilers, const DownstreamCompilerMatchVersion& version); + static IDownstreamCompiler* findClosestCompiler(const DownstreamCompilerSet* set, const DownstreamCompilerMatchVersion& version); + + /// Get the information on the compiler used to compile this source + static DownstreamCompilerMatchVersion getCompiledVersion(); + + static void updateDefault(DownstreamCompilerSet* set, SlangSourceLanguage sourceLanguage); + static void updateDefaults(DownstreamCompilerSet* set); + + static void setDefaultLocators(DownstreamCompilerLocatorFunc outFuncs[int(SLANG_PASS_THROUGH_COUNT_OF)]); + + /// Attempts to determine what 'path' is and load appropriately. Is it a path to a shared library? Is it a directory holding the libraries? + /// Some downstream shared libraries need other shared libraries to be loaded before the main shared library, such that they are in the same directory + /// otherwise the shared library could come from some unwanted location. + /// dependentNames names shared libraries which should be attempted to be loaded in the path of the main shared library. + /// The list is optional (nullptr can be passed in), and the list is terminated by nullptr. + static SlangResult loadSharedLibrary(const String& path, ISlangSharedLibraryLoader* loader, const char*const* dependantNames, const char* libraryName, ComPtr& outSharedLib); + + /// Append the desc as text + static void appendAsText(const DownstreamCompilerDesc& desc, StringBuilder& out); +}; + +} + +#endif -- cgit v1.2.3