From 79dd12c21e8f5c5ce01051a280679cf6ac8ffe97 Mon Sep 17 00:00:00 2001 From: jsmall-nvidia Date: Tue, 26 Apr 2022 12:09:32 -0400 Subject: Linking in DXC (#2190) * #include an absolute path didn't work - because paths were taken to always be relative. * Compile to a dxil library. * Added CompileProduct. * Support handling of ModuleLibrary. * CacheBehavior -> Cache * Use CompileProduct for -r references. * CompileProduct -> Artifact. * Determining an artifact type on binding. * Determine binary linkability. * Added Artifact::exists. * Added ArtifactKeep. * Small fixes. * Small improvements to Artifact. * Add zip extension. * Fix some comments. * Fix multiple adding of PublicDecoration. Make public output export for DXIL/lib. Add checking for simpleDecorations such that only added once. * Use 'whole program' to identify library build. * Move slang-artifact into compiler-core. * Split out Keep free functions. * Artifact::Keep -> ArtifactKeep. * Handle libraries as artifacts. * Add -target dxil so test infrastructure knows it needs DXC. * Linking working in DXC. * Improve handling around emit for 'export'. * Add comment around Artifact name. * Render test working with linking. Co-authored-by: Theresa Foley <10618364+tangent-vector@users.noreply.github.com> --- source/compiler-core/slang-artifact.cpp | 459 +++++++++++++++++ source/compiler-core/slang-artifact.h | 366 ++++++++++++++ source/compiler-core/slang-downstream-compiler.h | 4 +- source/compiler-core/slang-dxc-compiler.cpp | 236 +++++++-- source/compiler-core/slang-gcc-compiler-util.cpp | 51 ++ .../slang-visual-studio-compiler-util.cpp | 14 +- source/core/slang-command-line.cpp | 11 +- source/slang/slang-artifact.cpp | 544 --------------------- source/slang/slang-artifact.h | 370 -------------- source/slang/slang-compiler.cpp | 11 +- source/slang/slang-emit-hlsl.cpp | 13 +- source/slang/slang-ir-link.cpp | 5 +- source/slang/slang-module-library.cpp | 95 ++++ source/slang/slang-module-library.h | 28 ++ source/slang/slang-options.cpp | 3 +- source/slang/slang.cpp | 6 +- 16 files changed, 1251 insertions(+), 965 deletions(-) create mode 100644 source/compiler-core/slang-artifact.cpp create mode 100644 source/compiler-core/slang-artifact.h delete mode 100644 source/slang/slang-artifact.cpp delete mode 100644 source/slang/slang-artifact.h create mode 100644 source/slang/slang-module-library.cpp create mode 100644 source/slang/slang-module-library.h (limited to 'source') diff --git a/source/compiler-core/slang-artifact.cpp b/source/compiler-core/slang-artifact.cpp new file mode 100644 index 000000000..5d9f8692c --- /dev/null +++ b/source/compiler-core/slang-artifact.cpp @@ -0,0 +1,459 @@ +// slang-artifact.cpp +#include "slang-artifact.h" + +#include "../core/slang-type-text-util.h" +#include "../core/slang-io.h" + +namespace Slang { + +namespace { // anonymous +struct KindExtension +{ + ArtifactKind kind; + UnownedStringSlice ext; +}; +} // anonymous + +#define SLANG_KIND_EXTENSION(kind, ext) \ + { ArtifactKind::kind, UnownedStringSlice::fromLiteral(ext) }, + +static const KindExtension g_cpuKindExts[] = +{ +#if SLANG_WINDOWS_FAMILY + SLANG_KIND_EXTENSION(Library, "lib") + SLANG_KIND_EXTENSION(ObjectCode, "obj") + SLANG_KIND_EXTENSION(Executable, "exe") + SLANG_KIND_EXTENSION(SharedLibrary, "dll") +#else + SLANG_KIND_EXTENSION(Library, "a") + SLANG_KIND_EXTENSION(ObjectCode, "o") + SLANG_KIND_EXTENSION(Executable, "") + +#if __CYGWIN__ + SLANG_KIND_EXTENSION(SharedLibrary, "dll") +#elif SLANG_APPLE_FAMILY + SLANG_KIND_EXTENSION(SharedLibrary, "dylib") +#else + SLANG_KIND_EXTENSION(SharedLibrary, "so") +#endif + +#endif +}; + +/* static */ArtifactDesc ArtifactDesc::fromPath(const UnownedStringSlice& slice) +{ + auto extension = Path::getPathExt(slice); + return fromExtension(extension); +} + +/* static */ ArtifactDesc ArtifactDesc::fromExtension(const UnownedStringSlice& slice) +{ + if (slice == "slang-module" || + slice == "slang-lib") + { + return make(ArtifactKind::Library, ArtifactPayload::SlangIR, ArtifactStyle::Unknown); + } + + for (const auto& kindExt : g_cpuKindExts) + { + if (slice == kindExt.ext) + { + // We'll assume it's for the host CPU for now.. + return make(kindExt.kind, Payload::HostCPU, Style::Unknown); + } + } + + const auto target = TypeTextUtil::findCompileTargetFromExtension(slice); + + return makeFromCompileTarget(target); +} + +/* static */ArtifactDesc ArtifactDesc::makeFromCompileTarget(SlangCompileTarget target) +{ + switch (target) + { + case SLANG_TARGET_UNKNOWN: return make(Kind::Unknown, Payload::None, Style::Unknown, 0); + case SLANG_TARGET_NONE: return make(Kind::None, Payload::None, Style::Unknown, 0); + case SLANG_GLSL_VULKAN: + case SLANG_GLSL_VULKAN_ONE_DESC: + case SLANG_GLSL: + { + // For the moment we make all just map to GLSL, but we could use flags + // or some other mechanism to distinguish the types + return make(Kind::Text, Payload::GLSL, Style::Kernel, 0); + } + case SLANG_HLSL: return make(Kind::Text, Payload::HLSL, Style::Kernel, 0); + case SLANG_SPIRV: return make(Kind::Executable, Payload::SPIRV, Style::Kernel, 0); + case SLANG_SPIRV_ASM: return make(Kind::Text, Payload::SPIRVAssembly, Style::Kernel, 0); + case SLANG_DXBC: return make(Kind::Executable, Payload::DXBC, Style::Kernel, 0); + case SLANG_DXBC_ASM: return make(Kind::Text, Payload::DXBCAssembly, Style::Kernel, 0); + case SLANG_DXIL: return make(Kind::Executable, Payload::DXIL, Style::Kernel, 0); + case SLANG_DXIL_ASM: return make(Kind::Text, Payload::DXILAssembly, Style::Kernel, 0); + case SLANG_C_SOURCE: return make(Kind::Text, Payload::C, Style::Kernel, 0); + case SLANG_CPP_SOURCE: return make(Kind::Text, Payload::CPP, Style::Kernel, 0); + case SLANG_HOST_CPP_SOURCE: return make(Kind::Text, Payload::CPP, Style::Host, 0); + case SLANG_HOST_EXECUTABLE: return make(Kind::Executable, Payload::HostCPU, Style::Host, 0); + case SLANG_SHADER_SHARED_LIBRARY: return make(Kind::SharedLibrary, Payload::HostCPU, Style::Kernel, 0); + case SLANG_SHADER_HOST_CALLABLE: return make(Kind::Callable, Payload::HostCPU, Style::Kernel, 0); + case SLANG_CUDA_SOURCE: return make(Kind::Text, Payload::CUDA, Style::Kernel, 0); + case SLANG_PTX: return make(Kind::Executable, Payload::PTX, Style::Kernel, 0); + case SLANG_OBJECT_CODE: return make(Kind::ObjectCode, Payload::HostCPU, Style::Kernel, 0); + default: break; + } + + SLANG_UNEXPECTED("Unhandled type"); +} + +/* static */bool ArtifactDesc::isPayloadGpuBinary(Payload payloadType) +{ + switch (payloadType) + { + case Payload::DXIL: + case Payload::DXBC: + case Payload::SPIRV: + case Payload::PTX: + { + return true; + } + default: break; + } + return false; +} + +/* static */bool ArtifactDesc::isPayloadCpuBinary(Payload payloadType) +{ + switch (payloadType) + { + case Payload::X86: + case Payload::X86_64: + case Payload::AARCH: + case Payload::AARCH64: + case Payload::HostCPU: + { + return true; + } + default: break; + } + return false; +} + +/* static */bool ArtifactDesc::isPayloadGpuBinaryLinkable(Payload payload) +{ + switch (payload) + { + case Payload::DXBC: + { + // It seems as if DXBC is potentially linkable from + // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-keywords#export + return true; + } + + case Payload::DXIL: + case Payload::PTX: + case Payload::SPIRV: + { + // We can't *actually* link PTX or SPIR-V currently but it is in principal possible + // so let's say we accept for now + return true; + } + default: break; + } + return false; +} + +bool ArtifactDesc::isBinaryLinkable() const +{ + if (isKindBinaryLinkable(kind)) + { + return isPayloadCpuBinary(payload) || isPayloadGpuBinaryLinkable(payload) || payload == ArtifactPayload::SlangIR; + } + + return false; +} + +/* static */bool ArtifactDesc::isKindBinaryLinkable(Kind kind) +{ + switch (kind) + { + case Kind::Library: + case Kind::ObjectCode: + { + return true; + } + default: break; + } + return false; +} + +/* static*/ UnownedStringSlice ArtifactDesc::getCpuExtensionForKind(Kind kind) +{ + for (const auto& kindExt : g_cpuKindExts) + { + if (kind == kindExt.kind) + { + return kindExt.ext; + } + } + return UnownedStringSlice(); +} + +UnownedStringSlice ArtifactDesc::getDefaultExtension() +{ + if (isPayloadCpuBinary(payload)) + { + return getCpuExtensionForKind(kind); + } + else + { + return getDefaultExtensionForPayload(payload); + } +} + +/* static */UnownedStringSlice ArtifactDesc::getDefaultExtensionForPayload(Payload payload) +{ + switch (payload) + { + case Payload::None: return UnownedStringSlice(); + case Payload::Unknown: return UnownedStringSlice::fromLiteral("unknown"); + + case Payload::DXIL: return UnownedStringSlice::fromLiteral("dxil"); + case Payload::DXBC: return UnownedStringSlice::fromLiteral("dxbc"); + case Payload::SPIRV: return UnownedStringSlice::fromLiteral("spirv"); + + case Payload::PTX: return UnownedStringSlice::fromLiteral("ptx"); + + case Payload::X86: + case Payload::X86_64: + case Payload::AARCH: + case Payload::AARCH64: + case Payload::HostCPU: + { + return UnownedStringSlice(); + } + + case Payload::SlangIR: return UnownedStringSlice::fromLiteral("slang-ir"); + case Payload::LLVMIR: return UnownedStringSlice::fromLiteral("llvm-ir"); + + case Payload::HLSL: return UnownedStringSlice::fromLiteral("hlsl"); + case Payload::GLSL: return UnownedStringSlice::fromLiteral("glsl"); + + case Payload::CPP: return UnownedStringSlice::fromLiteral("cpp"); + case Payload::C: return UnownedStringSlice::fromLiteral("c"); + + case Payload::CUDA: return UnownedStringSlice::fromLiteral("cu"); + + case Payload::Slang: return UnownedStringSlice::fromLiteral("slang"); + + case Payload::Zip: return UnownedStringSlice::fromLiteral("zip"); + + default: break; + } + + SLANG_UNEXPECTED("Unknown content type"); +} + +/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Artifact !!!!!!!!!!!!!!!!!!!!!!!!!!! */ + +Artifact::~Artifact() +{ + if (m_pathType == PathType::Temporary) + { + File::remove(m_path); + } + + for (const auto& entry : m_entries) + { + // Release the associated data + switch (entry.type) + { + case Entry::Type::ObjectInstance: + { + entry.object->releaseReference(); + break; + } + case Entry::Type::InterfaceInstance: + { + entry.intf->release(); + break; + } + default: break; + } + } +} + +Index Artifact::indexOf(Entry::Type type) const +{ + return m_entries.findFirstIndex([&](const Entry& entry) -> bool { return entry.type == type; }); +} + +void Artifact::add(Entry::Style style, RefObject* obj) +{ + SLANG_ASSERT(obj); + + Entry entry; + entry.type = Entry::Type::ObjectInstance; + entry.style = style; + entry.object = obj; + + obj->addReference(); + + m_entries.add(entry); +} + +void Artifact::add(Entry::Style style, ISlangUnknown* intf) +{ + // Can't be nullptr + SLANG_ASSERT(intf); + + Entry entry; + entry.type = Entry::Type::InterfaceInstance; + entry.style = style; + + intf->addRef(); + + entry.intf = intf; + m_entries.add(entry); +} + +bool Artifact::exists() const +{ + // If we have a blob it exists + if (m_blob) + { + return true; + } + + // If we have an associated entry that represents the artifact it exists + for (const auto& entry : m_entries) + { + if (entry.style == Entry::Style::Artifact) + { + // There is a representation that 'is' the artifact + return true; + } + } + + // If we don't have a path then it can't exist + if (m_pathType == PathType::None) + { + return false; + } + + // If the file exists we assume it exists + return File::exists(m_path); +} + +ISlangUnknown* Artifact::findInterfaceInstance(const Guid& guid) +{ + for (const auto& entry : m_entries) + { + if (entry.type == Entry::Type::InterfaceInstance) + { + ISlangUnknown* intf = nullptr; + if (SLANG_SUCCEEDED(entry.intf->queryInterface(guid, (void**)&intf)) && intf) + { + // NOTE! This assumes we *DONT* need to ref count to keep an interface in scope + // (as strict COM requires so as to allow on demand interfaces). + intf->release(); + + return intf; + } + } + } + + return nullptr; +} + +SlangResult Artifact::requireFilePath(Keep keep, String& outFilePath) +{ + if (m_pathType != PathType::None) + { + outFilePath = m_path; + return SLANG_OK; + } + + ComPtr blob; + + // Get the contents as a blob. If we can't do that, then we can't write anything... + SLANG_RETURN_ON_FAIL(loadBlob(getIntermediateKeep(keep), blob)); + + const UnownedStringSlice ext = m_desc.getDefaultExtension(); + + // TODO(JS): NOTE! This isn't strictly correct, as the generated filename is not guarenteed to be unique + // if we change it with an extension (or prefix). + // This doesn't change the previous behavior though. + String path; + SLANG_RETURN_ON_FAIL(File::generateTemporary(UnownedStringSlice::fromLiteral("slang-generated"), path)); + + if (m_desc.isCpuBinary() && m_desc.kind == ArtifactKind::SharedLibrary) + { + const bool isSharedLibraryPrefixPlatform = SLANG_LINUX_FAMILY || SLANG_APPLE_FAMILY; + if (isSharedLibraryPrefixPlatform) + { + StringBuilder buf; + buf << "lib"; + buf << Path::getFileName(path); + + auto parentDir = Path::getParentDirectory(path); + if (parentDir.getLength()) + { + // Combine the name with path if their is a parent + path = Path::combine(parentDir, buf); + } + else + { + // Just use the name as is + path = buf; + } + } + } + + // If there is an extension append it + if (ext.getLength()) + { + path.appendChar('.'); + path.append(ext); + } + + SLANG_RETURN_ON_FAIL(File::writeAllBytes(path, blob->getBufferPointer(), blob->getBufferSize())); + + // Okay we can now add this as temporary path too + setPath(PathType::Temporary, path); + + return SLANG_OK; +} + +SlangResult Artifact::loadBlob(Keep keep, ComPtr& outBlob) +{ + if (m_blob) + { + outBlob = m_blob; + return SLANG_OK; + } + + // TODO(JS): + // Strictly speaking we could *potentially* convert some other representation into + // a blob by serializing it, but we don't worry about any of that here + if (m_pathType == PathType::None) + { + return SLANG_E_NOT_FOUND; + } + + // Read into a blob + ScopedAllocation alloc; + SLANG_RETURN_ON_FAIL(File::readAllBytes(m_path, alloc)); + + // Create as a blob + RefPtr blob = RawBlob::moveCreate(alloc); + + // Put in cache + if (canKeep(keep)) + { + setBlob(blob); + } + + outBlob = blob; + return SLANG_OK; +} + +} // namespace Slang diff --git a/source/compiler-core/slang-artifact.h b/source/compiler-core/slang-artifact.h new file mode 100644 index 000000000..232e9a8eb --- /dev/null +++ b/source/compiler-core/slang-artifact.h @@ -0,0 +1,366 @@ +// slang-artifact.h +#ifndef SLANG_ARTIFACT_H +#define SLANG_ARTIFACT_H + +#include "../core/slang-basic.h" + +#include "../../slang-com-helper.h" +#include "../../slang-com-ptr.h" + +namespace Slang +{ + +enum class ArtifactKind : uint8_t +{ + None, ///< There is no container + + Unknown, ///< There is a container of unknown type + + Library, ///< Library of object code (typically made up multiple ObjectCode) + ObjectCode, ///< Object code (for CPU typically .o or .obj file types) + + Executable, ///< Self contained such it can exectuted. On GPU this would be a kernel. + SharedLibrary, ///< Shared library/dll + Callable, ///< Callable directly (typically means there isn't a binary artifact) + + Text, ///< Text + + Container, ///< A container holding other things + + CountOf, +}; + +enum class ArtifactPayload : uint8_t +{ + None, ///< There is no payload + + Unknown, ///< Has payload but its unknown variety + + DXIL, + DXBC, + SPIRV, + PTX, + + DXILAssembly, + DXBCAssembly, + SPIRVAssembly, + PTXAssembly, + + HostCPU, ///< The host CPU architecture + + SlangIR, ///< Slang IR + LLVMIR, ///< LLVM IR + + SlangAST, ///< Slang AST + + X86, + X86_64, + AARCH, + AARCH64, + + HLSL, ///< HLSL + GLSL, ///< GLSL + CPP, ///< C++ + C, ///< C Language + CUDA, ///< CUDA + Slang, ///< Slang + + DebugInfo, ///< Debug information + + Zip, ///< It's a zip + + CountOf, +}; + +enum class ArtifactStyle : uint8_t +{ + Unknown, ///< Unknown + + Kernel, ///< Compiled as `GPU kernel` style. + Host, ///< Compiled in `host` style + + CountOf, +}; + +typedef uint8_t ArtifactFlags; +struct ArtifactFlag +{ + enum Enum : ArtifactFlags + { + // Don't currently have any flags + }; +}; + +// Controls what items can be kept. +enum class ArtifactKeep +{ + No, ///< Don't keep the item + Yes, ///< Yes keep the final item + All, ///< Keep the final item and any intermediataries +}; + + +/** +A value type to describe aspects of the contents of an Artifact. +**/ +struct ArtifactDesc +{ +public: + typedef ArtifactDesc This; + + typedef ArtifactKind Kind; + typedef ArtifactPayload Payload; + typedef ArtifactStyle Style; + typedef ArtifactFlags Flags; + + typedef uint32_t PackedBacking; + enum class Packed : PackedBacking; + + /// Get in packed format + inline Packed getPacked() const; + + /// True if the container appears to be binary linkable + bool isBinaryLinkable() const; + /// True if is a CPU binary + bool isCpuBinary() const { return isPayloadCpuBinary(payload); } + /// True if is a GPU binary + bool isGpuBinary() const { return isPayloadGpuBinary(payload); } + + /// Gets the default file extension for the artifact type. Returns empty slice if not known + UnownedStringSlice getDefaultExtension(); + + static UnownedStringSlice getDefaultExtensionForPayload(Payload payload); + + /// Get the extension for CPU/Host for a kind + static UnownedStringSlice getCpuExtensionForKind(Kind kind); + + /// Returns true if the kind is binary linkable + static bool isKindBinaryLinkable(Kind kind); + + /// Returns true if the payload type is CPU + static bool isPayloadCpuBinary(Payload payload); + /// Returns true if the payload type is applicable to the GPU + static bool isPayloadGpuBinary(Payload payload); + + /// True if the payload type is in principal binary linkable + static bool isPayloadGpuBinaryLinkable(Payload payload); + + /// Try to determine the desc from a path + static This fromPath(const UnownedStringSlice& slice); + /// Try to determine the desc from just a file extension (passed without .) + static This fromExtension(const UnownedStringSlice& slice); + + bool operator==(const This& rhs) const { return kind == rhs.kind && payload == rhs.payload && style == rhs.style && flags == rhs.flags; } + bool operator!=(const This& rhs) const { return !(*this == rhs); } + + /// Given a code gen target, get the equivalent ArtifactDesc + static This makeFromCompileTarget(SlangCompileTarget target); + + /// Construct from the elements + static This make(Kind inKind, Payload inPayload, Style inStyle = Style::Kernel, Flags flags = 0) + { + return This{ inKind, inPayload, inStyle, flags }; + } + /// Construct from the packed format + inline static This make(Packed inPacked); + + Kind kind; + Payload payload; + Style style; + Flags flags; +}; + +// -------------------------------------------------------------------------- +inline ArtifactDesc::Packed ArtifactDesc::getPacked() const +{ + typedef PackedBacking IntType; + return Packed((IntType(kind) << 24) | + (IntType(payload) << 16) | + (IntType(style) << 8) | + flags); +} + +// -------------------------------------------------------------------------- +inline /* static */ArtifactDesc ArtifactDesc::make(Packed inPacked) +{ + const PackedBacking packed = PackedBacking(inPacked); + + This r; + r.kind = Kind(packed >> 24); + r.payload = Payload(uint8_t(packed >> 16)); + r.style = Style(uint8_t(packed >> 8)); + r.flags = uint8_t(packed); + + return r; +} + +/* The Artifact type is a type designed to represent some Artifact of compilation. It could be input to or output from a compilation. + +An abstraction is desirable here, because depending on the compiler the artifact/s could be + +* A file on the file system +* A blob +* Multiple files +* Some other (perhaps multiple) in memory representations + +The artifact uses the Blob as the standard representation of in memory data. + +Some downstream compilers require the artifact to be available as a file system file, or to produce +artifacts that are files. The Artifact type allows to abstract away this difference, including the +ability to turn an in memory representation into a temporary file on the system file. + +The mechanism also allows for 'Containers' which allow for Artifacts to contain other Artifacts (amongst other things). +Those artifacts may be other files. For example a downstream compilation that produces results as well as temporary +files could be a Container containing artifacts for + +* Diagnostics +* Temporary files (of known and unknown types) +* Files that contain known types +* Callable interface (an ISlangSharedLibrary) + +A more long term goal would be to + +* Make Artifact an interface (such that it can work long term over binary boundaries) +* Make Diagnostics into an interface (such it can be added to a Artifact result) +* Use Artifact and related types for downstream compiler + +TODO(JS): There is an issue here around libraries in that downstream compilers can use +named libraries, but the name doesn't directly relate to a file. If it is a file it may +not be easily possible to determine it's location. So there is a desire to indicate the +`name` as opposed to the path. + +As a second related issue. Lets say we have a blob (and not a file). + +*/ +class Artifact : public RefObject +{ +public: + + typedef ArtifactDesc Desc; + + typedef ArtifactKind Kind; + typedef ArtifactPayload Payload; + typedef ArtifactStyle Style; + typedef ArtifactFlags Flags; + typedef ArtifactKeep Keep; + + enum PathType + { + None, + Temporary, + Existing, + }; + + /* A compile product can be made up of multiple representations. + */ + struct Entry + { + /// NOTE! Only interface innstances work across dll/shared library boundaries + /// because casting other types does not work across those boundaries. + + // The Type of the entry + enum class Type : uint8_t + { + InterfaceInstance, ///< An interface instance + ObjectInstance, ///< An object instance + RawInstance, + }; + enum class Style : uint8_t + { + Artifact, ///< Means this entry *can* represent the whole artifact + Child, ///< Some part of the artifact + Info, ///< Informational + Other, ///< Other + }; + + Type type; + Style style; + union + { + RefObject* object; + ISlangUnknown* intf; + void* raw; + }; + }; + + /// Given a type T find the associated instance + template + T* findObjectInstance(); + + /// Finds an instance of that has the guid. + ISlangUnknown* findInterfaceInstance(const Guid& guid); + + /// Returns true if the artifact in principal exists (it could be invalid) + bool exists() const; + + /// Load as a blob + SlangResult loadBlob(Keep keep, ComPtr& outBlob); + + /// Get as a file. May need to serialize and write as a temporary file. + SlangResult requireFilePath(Keep keep, String& outPath); + + SLANG_FORCE_INLINE const Desc& getDesc() { return m_desc; } + + /// Returns the index of the entry + Index indexOf(Entry::Type type) const; + + /// Add items + void setPath(PathType pathType, const String& filePath) { m_pathType = pathType; m_path = filePath; } + void setBlob(ISlangBlob* blob) { m_blob = blob; } + + void add(Entry::Style style, RefObject* obj); + void add(Entry::Style style, ISlangUnknown* intf); + + PathType getPathType() const { return m_pathType; } + const String& getPath() const { return m_path; } + + const List& getEntries() const { return m_entries; } + + /// Ctor + Artifact(const Desc& desc) :m_desc(desc) {} + /// Dtor + ~Artifact(); + +protected: + Desc m_desc; + + PathType m_pathType = PathType::None; ///< What the path indicates + String m_path; ///< The path + + ComPtr m_blob; ///< Blob to store result in memory + + List m_entries; +}; + +// ---------------------------------------------------------------------- +template +T* Artifact::findObjectInstance() +{ + RefObject* check = static_cast(nullptr); + SLANG_UNUSED(check); + + // Check if we already have it + for (const auto& entry : m_entries) + { + if (entry.type == Entry::Type::ObjectInstance) + { + auto obj = as(entry.object); + if (obj) + { + return obj; + } + } + } + return nullptr; +} + +/// True if can keep an intermediate item +SLANG_INLINE bool canKeepIntermediate(ArtifactKeep keep) { return keep == ArtifactKeep::All; } + /// True if can keep +SLANG_INLINE bool canKeep(ArtifactKeep keep) { return Index(keep) >= Index(ArtifactKeep::Yes); } + /// Returns the keep type for an intermediate +SLANG_INLINE ArtifactKeep getIntermediateKeep(ArtifactKeep keep) { return (keep == ArtifactKeep::All) ? ArtifactKeep::All : ArtifactKeep::No; } + +} // namespace Slang + +#endif diff --git a/source/compiler-core/slang-downstream-compiler.h b/source/compiler-core/slang-downstream-compiler.h index e40ffc13a..e6c1f7a40 100644 --- a/source/compiler-core/slang-downstream-compiler.h +++ b/source/compiler-core/slang-downstream-compiler.h @@ -13,6 +13,8 @@ #include "../../slang-com-ptr.h" +#include "slang-artifact.h" + namespace Slang { @@ -303,7 +305,7 @@ public: List libraryPaths; /// Libraries to link against. - List libraries; + List> libraries; List requiredCapabilityVersions; diff --git a/source/compiler-core/slang-dxc-compiler.cpp b/source/compiler-core/slang-dxc-compiler.cpp index f5db290b1..eb26dd3cc 100644 --- a/source/compiler-core/slang-dxc-compiler.cpp +++ b/source/compiler-core/slang-dxc-compiler.cpp @@ -50,6 +50,52 @@ static UnownedStringSlice _getSlice(IDxcBlob* blob) { return StringUtil::getSlic // 7f61fc7d-950d-467f-b3e3-3c02fb49187c static const Guid IID_IDxcIncludeHandler = { 0x7f61fc7d, 0x950d, 0x467f, { 0x3c, 0x02, 0xfb, 0x49, 0x18, 0x7c } }; +namespace { // anonymous + +class LibraryNameList +{ +public: + void addName(Artifact* library) + { + String name; + if (library->getPathType() == Artifact::Existing) + { + name = Path::getFileNameWithoutExt(library->getPath()); + } + addName(name); + } + void addName(const String& inName) + { + String name(inName); + if (name.getLength() == 0) + { + name = "unnamed"; + } + + if (m_names.indexOf(name) >= 0) + { + StringBuilder buf; + for (Index i = 1; ; ++i) + { + buf.Clear(); + buf << name << "_" << i; + + if (m_names.indexOf(buf) < 0) + { + name = buf; + break; + } + } + } + + m_names.add(name); + } + + List m_names; +}; + +} // anonymous + class DxcIncludeHandler : public IDxcIncludeHandler { public: @@ -137,6 +183,8 @@ public: protected: DxcCreateInstanceProc m_createInstance = nullptr; + + ComPtr m_sharedLibrary; }; @@ -183,6 +231,60 @@ static SlangResult _parseDiagnosticLine(const UnownedStringSlice& line, List& outBlob) +{ + // Retrieve result. + HRESULT resultCode = S_OK; + SLANG_RETURN_ON_FAIL(dxcResult->GetStatus(&resultCode)); + + // Note: it seems like the dxcompiler interface + // doesn't support querying diagnostic output + // *unless* the compile failed (no way to get + // warnings out!?). + + if (SLANG_SUCCEEDED(ioDiagnostics.result)) + { + ioDiagnostics.result = resultCode; + } + + // Try getting the error/diagnostics blob + ComPtr dxcErrorBlob; + dxcResult->GetErrorBuffer(dxcErrorBlob.writeRef()); + + if (dxcErrorBlob) + { + const UnownedStringSlice diagnosticsSlice = _getSlice(dxcErrorBlob); + if (diagnosticsSlice.getLength()) + { + if (ioDiagnostics.rawDiagnostics.getLength() > 0) + { + ioDiagnostics.rawDiagnostics.append("\n"); + } + ioDiagnostics.rawDiagnostics.append(diagnosticsSlice); + + SlangResult diagnosticParseRes = DownstreamDiagnostic::parseColonDelimitedDiagnostics(diagnosticsSlice, 0, _parseDiagnosticLine, ioDiagnostics.diagnostics); + + SLANG_UNUSED(diagnosticParseRes); + SLANG_ASSERT(SLANG_SUCCEEDED(diagnosticParseRes)); + } + } + + // If it failed, make sure we have an error in the diagnostics + if (SLANG_FAILED(resultCode)) + { + // In case the parsing failed, we still have an error -> so require there is one in the diagnostics + ioDiagnostics.requireErrorDiagnostic(); + } + else + { + // Okay, the compile supposedly succeeded, so we + // just need to grab the buffer with the output DXIL. + SLANG_RETURN_ON_FAIL(dxcResult->GetResult(outBlob.writeRef())); + } + + return SLANG_OK; +} + SlangResult DXCDownstreamCompiler::compile(const CompileOptions& options, RefPtr& outResult) { // This compiler doesn't read files, they should be read externally and stored in sourceContents/sourceContentsPath @@ -197,6 +299,22 @@ SlangResult DXCDownstreamCompiler::compile(const CompileOptions& options, RefPtr return SLANG_FAIL; } + // Find all of the libraries + List libraries; + for (Artifact* library : options.libraries) + { + const auto desc = library->getDesc(); + + if (desc.kind == ArtifactKind::Library && desc.payload == ArtifactPayload::DXIL) + { + // Make sure they all have blobs + ComPtr libraryBlob; + SLANG_RETURN_ON_FAIL(library->loadBlob(ArtifactKeep::Yes, libraryBlob)); + + libraries.add(library); + } + } + ComPtr dxcCompiler; SLANG_RETURN_ON_FAIL(m_createInstance(CLSID_DxcCompiler, __uuidof(dxcCompiler), (LPVOID*)dxcCompiler.writeRef())); ComPtr dxcLibrary; @@ -289,8 +407,28 @@ SlangResult DXCDownstreamCompiler::compile(const CompileOptions& options, RefPtr // args.add(L"-no-warnings"); + String profileName = options.profileName; + // If we are going to link we have to compile in the lib profile style + if (libraries.getCount()) + { + if (!profileName.startsWith("lib")) + { + const Index index = profileName.indexOf('_'); + if (index < 0) + { + profileName = "lib_6_3"; + } + else + { + StringBuilder buf; + buf << "lib" << profileName.getUnownedSlice().tail(index); + profileName = buf; + } + } + } + OSString wideEntryPointName = options.entryPointName.toWString(); - OSString wideProfileName = options.profileName.toWString(); + OSString wideProfileName = profileName.toWString(); if (options.flags & CompileOptions::Flag::EnableFloat16) { @@ -319,50 +457,80 @@ SlangResult DXCDownstreamCompiler::compile(const CompileOptions& options, RefPtr &includeHandler, // `#include` handler dxcResult.writeRef())); - // Retrieve result. - HRESULT resultCode = S_OK; - SLANG_RETURN_ON_FAIL(dxcResult->GetStatus(&resultCode)); - - // Note: it seems like the dxcompiler interface - // doesn't support querying diagnostic output - // *unless* the compile failed (no way to get - // warnings out!?). - DownstreamDiagnostics diagnostics; - diagnostics.result = resultCode; - // Try getting the error/diagnostics blob - ComPtr dxcErrorBlob; - dxcResult->GetErrorBuffer(dxcErrorBlob.writeRef()); + ComPtr dxcResultBlob; - if (dxcErrorBlob) + SLANG_RETURN_ON_FAIL(_handleOperationResult(dxcResult, diagnostics, dxcResultBlob)); + + // If we have libraries then we need to link... + if (libraries.getCount()) { - const UnownedStringSlice diagnosticsSlice = _getSlice(dxcErrorBlob); - if (diagnosticsSlice.getLength()) + ComPtr linker; + SLANG_RETURN_ON_FAIL(m_createInstance(CLSID_DxcLinker, __uuidof(linker), (void**)linker.writeRef())); + + List> libraryBlobs; + + LibraryNameList libraryNames; + + for (Artifact* library : libraries) { - diagnostics.rawDiagnostics = String(diagnosticsSlice); + ComPtr blob; + SLANG_RETURN_ON_FAIL(library->loadBlob(ArtifactKeep::Yes, blob)); - SlangResult diagnosticParseRes = DownstreamDiagnostic::parseColonDelimitedDiagnostics(diagnosticsSlice, 0, _parseDiagnosticLine, diagnostics.diagnostics); + libraryBlobs.add(blob); + libraryNames.addName(library); + } - SLANG_UNUSED(diagnosticParseRes); - SLANG_ASSERT(SLANG_SUCCEEDED(diagnosticParseRes)); + // Add the compiled blob name + + { + auto blob = (ISlangBlob*)dxcResultBlob.get(); + libraryBlobs.add(ComPtr(blob)); } - } - ComPtr dxcResultBlob; + if (options.modulePath.getLength()) + { + libraryNames.addName(Path::getFileNameWithoutExt(options.modulePath)); + } + else if (options.sourceContentsPath.getLength()) + { + libraryNames.addName(Path::getFileNameWithoutExt(options.sourceContentsPath)); + } + else + { + libraryNames.addName(""); + } - // If it failed, make sure we have an error in the diagnostics - if (SLANG_FAILED(resultCode)) - { - // In case the parsing failed, we still have an error -> so require there is one in the diagnostics - diagnostics.requireErrorDiagnostic(); + const Index librariesCount = libraryNames.m_names.getCount(); + SLANG_ASSERT(libraryBlobs.getCount() == librariesCount); + + List linkLibraryNames; + List wideLibraryNames; + + linkLibraryNames.setCount(librariesCount); + wideLibraryNames.setCount(librariesCount); + + for (Index i = 0; i < librariesCount; ++i) + { + wideLibraryNames[i] = libraryNames.m_names[i].toWString(); + linkLibraryNames[i] = wideLibraryNames[i].begin(); + + // Register the library + SLANG_RETURN_ON_FAIL(linker->RegisterLibrary(linkLibraryNames[i], (IDxcBlob*)libraryBlobs[i].get())); + } + + // Use the original profile name + wideProfileName = options.profileName.toWString(); + + ComPtr linkDxcResult; + SLANG_RETURN_ON_FAIL(linker->Link(wideEntryPointName.begin(), wideProfileName.begin(), linkLibraryNames.getBuffer(), UINT32(librariesCount), nullptr, 0, linkDxcResult.writeRef())); + + ComPtr linkedBlob; + SLANG_RETURN_ON_FAIL(_handleOperationResult(linkDxcResult, diagnostics, linkedBlob)); + + dxcResultBlob = linkedBlob; } - else - { - // Okay, the compile supposedly succeeded, so we - // just need to grab the buffer with the output DXIL. - SLANG_RETURN_ON_FAIL(dxcResult->GetResult(dxcResultBlob.writeRef())); - } outResult = new BlobDownstreamCompileResult(diagnostics, (ISlangBlob*)dxcResultBlob.get()); return SLANG_OK; diff --git a/source/compiler-core/slang-gcc-compiler-util.cpp b/source/compiler-core/slang-gcc-compiler-util.cpp index 8d1b87b68..7d1b7b86a 100644 --- a/source/compiler-core/slang-gcc-compiler-util.cpp +++ b/source/compiler-core/slang-gcc-compiler-util.cpp @@ -619,6 +619,56 @@ static SlangResult _parseGCCFamilyLine(const UnownedStringSlice& line, LineParse cmdLine.addArg(sourceFile); } + // Add the library paths + List libraryPaths; + libraryPaths.addRange(options.libraryPaths.getBuffer(), options.libraryPaths.getCount()); + + // Artifacts might add library paths + for (Artifact* artifact : options.libraries) + { + const auto desc = artifact->getDesc(); + // If it's a library for CPU types, try and use it + if (desc.isCpuBinary()) + { + if (desc.kind == ArtifactKind::Library) + { + String path; + SLANG_RETURN_ON_FAIL(artifact->requireFilePath(ArtifactKeep::No, path)); + + String parentDir = Path::getParentDirectory(parentDir); + if (parentDir.getLength()) + { + // Check if we already have the library path, only add it if it's not found + if (libraryPaths.indexOf(parentDir) < 0) + { + libraryPaths.add(parentDir); + } + path = Path::getFileName(path); + } + + // If it starts with lib strip it + if (path.startsWith("lib")) + { + const String stripLib = path.getUnownedSlice().tail(3); + path = stripLib; + } + + // Strip the extension if it's a match + auto extension = Path::getPathExt(path); + if (extension.getLength()) + { + auto libExt = ArtifactDesc::make(ArtifactKind::Library, ArtifactPayload::HostCPU).getDefaultExtension(); + if (extension == libExt) + { + path = Path::getFileNameWithoutExt(path); + } + } + + cmdLine.addPrefixPathArg("-l", path); + } + } + } + for (const auto& libPath : options.libraryPaths) { // Note that any escaping of the path is handled in the ProcessUtil:: @@ -628,6 +678,7 @@ static SlangResult _parseGCCFamilyLine(const UnownedStringSlice& line, LineParse cmdLine.addArg(libPath); } + if (options.sourceLanguage == SLANG_SOURCE_LANGUAGE_CPP && !PlatformUtil::isFamily(PlatformFamily::Windows, platformKind)) { // Make STD libs available diff --git a/source/compiler-core/slang-visual-studio-compiler-util.cpp b/source/compiler-core/slang-visual-studio-compiler-util.cpp index 2ba69c1ce..df64ed821 100644 --- a/source/compiler-core/slang-visual-studio-compiler-util.cpp +++ b/source/compiler-core/slang-visual-studio-compiler-util.cpp @@ -257,9 +257,19 @@ namespace Slang } // Link libraries. - for (const auto& lib : options.libraries) + for (Artifact* artifact : options.libraries) { - cmdLine.addPrefixPathArg("", lib, ".lib"); + if (artifact->getDesc().isCpuBinary()) + { + String path; + SLANG_RETURN_ON_FAIL(artifact->requireFilePath(ArtifactKeep::No, path)); + + if (Path::getPathExt(path).getLength() == 0) + { + path.append(".lib"); + } + cmdLine.addArg(path); + } } return SLANG_OK; diff --git a/source/core/slang-command-line.cpp b/source/core/slang-command-line.cpp index 973bb46d0..f8b5ff10f 100644 --- a/source/core/slang-command-line.cpp +++ b/source/core/slang-command-line.cpp @@ -71,7 +71,16 @@ void ExecutableLocation::append(StringBuilder& out) const void CommandLine::addPrefixPathArg(const char* prefix, const String& path, const char* pathPostfix) { StringBuilder builder; - builder << prefix << path; + builder << prefix; + + // TODO(JS): The assumption here is that quoting will be added as necessary and + // -prefixSomething Else + // is okay as + // "-prefixSomething Else" rather than + // -prefix"Something Else" + + builder << path; + if (pathPostfix) { // Work out the path with the postfix diff --git a/source/slang/slang-artifact.cpp b/source/slang/slang-artifact.cpp deleted file mode 100644 index 770f2202a..000000000 --- a/source/slang/slang-artifact.cpp +++ /dev/null @@ -1,544 +0,0 @@ -// slang-artifact.cpp -#include "slang-artifact.h" -#include - -#include "../core/slang-blob.h" -#include "../core/slang-riff.h" - -#include "../core/slang-type-text-util.h" - -// Serialization -#include "slang-serialize-ir.h" -#include "slang-serialize-container.h" - -namespace Slang { - -namespace { // anonymous -struct KindExtension -{ - ArtifactKind kind; - UnownedStringSlice ext; -}; -} // anonymous - -#define SLANG_KIND_EXTENSION(kind, ext) \ - { ArtifactKind::kind, UnownedStringSlice::fromLiteral(ext) }, - -static const KindExtension g_cpuKindExts[] = -{ -#if SLANG_WINDOWS_FAMILY - SLANG_KIND_EXTENSION(Library, "lib") - SLANG_KIND_EXTENSION(ObjectCode, "obj") - SLANG_KIND_EXTENSION(Executable, "exe") - SLANG_KIND_EXTENSION(SharedLibrary, "dll") -#else - SLANG_KIND_EXTENSION(Library, "a") - SLANG_KIND_EXTENSION(ObjectCode, "o") - SLANG_KIND_EXTENSION(Executable, "") - -#if __CYGWIN__ - SLANG_KIND_EXTENSION(SharedLibrary, "dll") -#elif SLANG_APPLE_FAMILY - SLANG_KIND_EXTENSION(SharedLibrary, "dylib") -#else - SLANG_KIND_EXTENSION(SharedLibrary, "so") -#endif - -#endif -}; - -/* static */ArtifactDesc ArtifactDesc::fromPath(const UnownedStringSlice& slice) -{ - auto extension = Path::getPathExt(slice); - return fromExtension(extension); -} - -/* static */ ArtifactDesc ArtifactDesc::fromExtension(const UnownedStringSlice& slice) -{ - if (slice == "slang-module" || - slice == "slang-lib") - { - return make(ArtifactKind::Library, ArtifactPayload::SlangIR, ArtifactStyle::Unknown); - } - - for (const auto& kindExt : g_cpuKindExts) - { - if (slice == kindExt.ext) - { - // We'll assume it's for the host CPU for now.. - return make(kindExt.kind, Payload::HostCPU, Style::Unknown); - } - } - - const auto target = (CodeGenTarget)TypeTextUtil::findCompileTargetFromExtension(slice); - - return make(target); -} - -/* static */ArtifactDesc ArtifactDesc::make(CodeGenTarget target) -{ - switch (target) - { - case CodeGenTarget::Unknown: return make(Kind::Unknown, Payload::None, Style::Unknown, 0); - case CodeGenTarget::None: return make(Kind::None, Payload::None, Style::Unknown, 0); - case CodeGenTarget::GLSL_Vulkan: - case CodeGenTarget::GLSL_Vulkan_OneDesc: - case CodeGenTarget::GLSL: - { - // For the moment we make all just map to GLSL, but we could use flags - // or some other mechanism to distinguish the types - return make(Kind::Text, Payload::GLSL, Style::Kernel, 0); - } - case CodeGenTarget::HLSL: return make(Kind::Text, Payload::HLSL, Style::Kernel, 0); - case CodeGenTarget::SPIRV: return make(Kind::Executable, Payload::SPIRV, Style::Kernel, 0); - case CodeGenTarget::SPIRVAssembly: return make(Kind::Text, Payload::SPIRVAssembly, Style::Kernel, 0); - case CodeGenTarget::DXBytecode: return make(Kind::Executable, Payload::DXBC, Style::Kernel, 0); - case CodeGenTarget::DXBytecodeAssembly: return make(Kind::Text, Payload::DXBCAssembly, Style::Kernel, 0); - case CodeGenTarget::DXIL: return make(Kind::Executable, Payload::DXIL, Style::Kernel, 0); - case CodeGenTarget::DXILAssembly: return make(Kind::Text, Payload::DXILAssembly, Style::Kernel, 0); - case CodeGenTarget::CSource: return make(Kind::Text, Payload::C, Style::Kernel, 0); - case CodeGenTarget::CPPSource: return make(Kind::Text, Payload::CPP, Style::Kernel, 0); - case CodeGenTarget::HostCPPSource: return make(Kind::Text, Payload::CPP, Style::Host, 0); - case CodeGenTarget::HostExecutable: return make(Kind::Executable, Payload::HostCPU, Style::Host, 0); - case CodeGenTarget::ShaderSharedLibrary: return make(Kind::SharedLibrary, Payload::HostCPU, Style::Kernel, 0); - case CodeGenTarget::ShaderHostCallable: return make(Kind::Callable, Payload::HostCPU, Style::Kernel, 0); - case CodeGenTarget::CUDASource: return make(Kind::Text, Payload::CUDA, Style::Kernel, 0); - case CodeGenTarget::PTX: return make(Kind::Executable, Payload::PTX, Style::Kernel, 0); - case CodeGenTarget::ObjectCode: return make(Kind::ObjectCode, Payload::HostCPU, Style::Kernel, 0); - default: break; - } - - SLANG_UNEXPECTED("Unhandled type"); -} - -/* static */bool ArtifactDesc::isPayloadGpuBinary(Payload payloadType) -{ - switch (payloadType) - { - case Payload::DXIL: - case Payload::DXBC: - case Payload::SPIRV: - case Payload::PTX: - { - return true; - } - default: break; - } - return false; -} - -/* static */bool ArtifactDesc::isPayloadCpuBinary(Payload payloadType) -{ - switch (payloadType) - { - case Payload::X86: - case Payload::X86_64: - case Payload::AARCH: - case Payload::AARCH64: - case Payload::HostCPU: - { - return true; - } - default: break; - } - return false; -} - -/* static */bool ArtifactDesc::isPayloadGpuBinaryLinkable(Payload payload) -{ - switch (payload) - { - case Payload::DXBC: - { - // It seems as if DXBC is potentially linkable from - // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-keywords#export - return true; - } - - case Payload::DXIL: - case Payload::PTX: - case Payload::SPIRV: - { - // We can't *actually* link PTX or SPIR-V currently but it is in principal possible - // so let's say we accept for now - return true; - } - default: break; - } - return false; -} - -bool ArtifactDesc::isBinaryLinkable() const -{ - if (isKindBinaryLinkable(kind)) - { - return isPayloadCpuBinary(payload) || isPayloadGpuBinaryLinkable(payload) || payload == ArtifactPayload::SlangIR; - } - - return false; -} - -/* static */bool ArtifactDesc::isKindBinaryLinkable(Kind kind) -{ - switch (kind) - { - case Kind::Library: - case Kind::ObjectCode: - { - return true; - } - default: break; - } - return false; -} - -/* static*/ UnownedStringSlice ArtifactDesc::getCpuExtensionForKind(Kind kind) -{ - for (const auto& kindExt : g_cpuKindExts) - { - if (kind == kindExt.kind) - { - return kindExt.ext; - } - } - return UnownedStringSlice(); -} - -UnownedStringSlice ArtifactDesc::getDefaultExtension() -{ - if (isPayloadCpuBinary(payload)) - { - return getCpuExtensionForKind(kind); - } - else - { - return getDefaultExtensionForPayload(payload); - } -} - -/* static */UnownedStringSlice ArtifactDesc::getDefaultExtensionForPayload(Payload payload) -{ - switch (payload) - { - case Payload::None: return UnownedStringSlice(); - case Payload::Unknown: return UnownedStringSlice::fromLiteral("unknown"); - - case Payload::DXIL: return UnownedStringSlice::fromLiteral("dxil"); - case Payload::DXBC: return UnownedStringSlice::fromLiteral("dxbc"); - case Payload::SPIRV: return UnownedStringSlice::fromLiteral("spirv"); - - case Payload::PTX: return UnownedStringSlice::fromLiteral("ptx"); - - case Payload::X86: - case Payload::X86_64: - case Payload::AARCH: - case Payload::AARCH64: - case Payload::HostCPU: - { - return UnownedStringSlice(); - } - - case Payload::SlangIR: return UnownedStringSlice::fromLiteral("slang-ir"); - case Payload::LLVMIR: return UnownedStringSlice::fromLiteral("llvm-ir"); - - case Payload::HLSL: return UnownedStringSlice::fromLiteral("hlsl"); - case Payload::GLSL: return UnownedStringSlice::fromLiteral("glsl"); - - case Payload::CPP: return UnownedStringSlice::fromLiteral("cpp"); - case Payload::C: return UnownedStringSlice::fromLiteral("c"); - - case Payload::CUDA: return UnownedStringSlice::fromLiteral("cu"); - - case Payload::Slang: return UnownedStringSlice::fromLiteral("slang"); - - case Payload::Zip: return UnownedStringSlice::fromLiteral("zip"); - - default: break; - } - - SLANG_UNEXPECTED("Unknown content type"); -} - -/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Artifact !!!!!!!!!!!!!!!!!!!!!!!!!!! */ - -Artifact::~Artifact() -{ - if (m_pathType == PathType::Temporary) - { - File::remove(m_path); - } - - for (const auto& entry : m_entries) - { - // Release the associated data - switch (entry.type) - { - case Entry::Type::ObjectInstance: - { - entry.object->releaseReference(); - break; - } - case Entry::Type::InterfaceInstance: - { - entry.intf->release(); - break; - } - default: break; - } - } -} - -Index Artifact::indexOf(Entry::Type type) const -{ - return m_entries.findFirstIndex([&](const Entry& entry) -> bool { return entry.type == type; }); -} - -void Artifact::add(Entry::Style style, RefObject* obj) -{ - SLANG_ASSERT(obj); - - Entry entry; - entry.type = Entry::Type::ObjectInstance; - entry.style = style; - entry.object = obj; - - obj->addReference(); - - m_entries.add(entry); -} - -void Artifact::add(Entry::Style style, ISlangUnknown* intf) -{ - // Can't be nullptr - SLANG_ASSERT(intf); - - Entry entry; - entry.type = Entry::Type::InterfaceInstance; - entry.style = style; - - intf->addRef(); - - entry.intf = intf; - m_entries.add(entry); -} - -bool Artifact::exists() const -{ - // If we have a blob it exists - if (m_blob) - { - return true; - } - - // If we have an associated entry that represents the artifact it exists - for (const auto& entry : m_entries) - { - if (entry.style == Entry::Style::Artifact) - { - // There is a representation that 'is' the artifact - return true; - } - } - - // If we don't have a path then it can't exist - if (m_pathType == PathType::None) - { - return false; - } - - // If the file exists we assume it exists - return File::exists(m_path); -} - -ISlangUnknown* Artifact::findInterfaceInstance(const Guid& guid) -{ - for (const auto& entry : m_entries) - { - if (entry.type == Entry::Type::InterfaceInstance) - { - ISlangUnknown* intf = nullptr; - if (SLANG_SUCCEEDED(entry.intf->queryInterface(guid, (void**)&intf)) && intf) - { - // NOTE! This assumes we *DONT* need to ref count to keep an interface in scope - // (as strict COM requires so as to allow on demand interfaces). - intf->release(); - - return intf; - } - } - } - - return nullptr; -} - -SlangResult Artifact::requireFilePath(Keep keep, String& outFilePath) -{ - if (m_pathType != PathType::None) - { - outFilePath = m_path; - return SLANG_OK; - } - - ComPtr blob; - - // Get the contents as a blob. If we can't do that, then we can't write anything... - SLANG_RETURN_ON_FAIL(loadBlob(getIntermediateKeep(keep), blob)); - - const UnownedStringSlice ext = m_desc.getDefaultExtension(); - - // TODO(JS): NOTE! This isn't strictly correct, as the generated filename is not guarenteed to be unique - // if we change it with an extension (or prefix). - // This doesn't change the previous behavior though. - String path; - SLANG_RETURN_ON_FAIL(File::generateTemporary(UnownedStringSlice::fromLiteral("slang-generated"), path)); - - if (m_desc.isCpuBinary() && m_desc.kind == ArtifactKind::SharedLibrary) - { - const bool isSharedLibraryPrefixPlatform = SLANG_LINUX_FAMILY || SLANG_APPLE_FAMILY; - if (isSharedLibraryPrefixPlatform) - { - StringBuilder buf; - buf << "lib"; - buf << Path::getFileName(path); - - auto parentDir = Path::getParentDirectory(path); - if (parentDir.getLength()) - { - // Combine the name with path if their is a parent - path = Path::combine(parentDir, buf); - } - else - { - // Just use the name as is - path = buf; - } - } - } - - // If there is an extension append it - if (ext.getLength()) - { - path.appendChar('.'); - path.append(ext); - } - - SLANG_RETURN_ON_FAIL(File::writeAllBytes(path, blob->getBufferPointer(), blob->getBufferSize())); - - // Okay we can now add this as temporary path too - setPath(PathType::Temporary, path); - - return SLANG_OK; -} - -SlangResult Artifact::loadBlob(Keep keep, ComPtr& outBlob) -{ - if (m_blob) - { - outBlob = m_blob; - return SLANG_OK; - } - - // TODO(JS): - // Strictly speaking we could *potentially* convert some other representation into - // a blob by serializing it, but we don't worry about any of that here - if (m_pathType == PathType::None) - { - return SLANG_E_NOT_FOUND; - } - - // Read into a blob - ScopedAllocation alloc; - SLANG_RETURN_ON_FAIL(File::readAllBytes(m_path, alloc)); - - // Create as a blob - RefPtr blob = RawBlob::moveCreate(alloc); - - // Put in cache - if (canKeep(keep)) - { - setBlob(blob); - } - - outBlob = blob; - return SLANG_OK; -} - -SlangResult loadModuleLibrary(const Byte* inBytes, size_t bytesCount, EndToEndCompileRequest* req, RefPtr& outLibrary) -{ - RefPtr library = new ModuleLibrary; - - // Load up the module - MemoryStreamBase memoryStream(FileAccess::Read, inBytes, bytesCount); - - RiffContainer riffContainer; - SLANG_RETURN_ON_FAIL(RiffUtil::read(&memoryStream, riffContainer)); - - auto linkage = req->getLinkage(); - - // TODO(JS): May be better to have a ITypeComponent that encapsulates a collection of modules - // For now just add to the linkage - - { - SerialContainerData containerData; - - SerialContainerUtil::ReadOptions options; - options.namePool = req->getNamePool(); - options.session = req->getSession(); - options.sharedASTBuilder = linkage->getASTBuilder()->getSharedASTBuilder(); - options.sourceManager = linkage->getSourceManager(); - options.linkage = req->getLinkage(); - options.sink = req->getSink(); - - SLANG_RETURN_ON_FAIL(SerialContainerUtil::read(&riffContainer, options, containerData)); - - for (const auto& module : containerData.modules) - { - // If the irModule is set, add it - if (module.irModule) - { - library->m_modules.add(module.irModule); - } - } - - for (const auto& entryPoint : containerData.entryPoints) - { - FrontEndCompileRequest::ExtraEntryPointInfo dst; - dst.mangledName = entryPoint.mangledName; - dst.name = entryPoint.name; - dst.profile = entryPoint.profile; - - // Add entry point - library->m_entryPoints.add(dst); - } - } - - outLibrary = library; - return SLANG_OK; -} - -SlangResult loadModuleLibrary(Artifact::Keep keep, Artifact* product, EndToEndCompileRequest* req, RefPtr& outLibrary) -{ - if (auto foundLibrary = product->findObjectInstance()) - { - outLibrary = foundLibrary; - return SLANG_OK; - } - - // Load the blob - ComPtr blob; - SLANG_RETURN_ON_FAIL(product->loadBlob(Artifact::getIntermediateKeep(keep), blob)); - - // Load the module - RefPtr library; - SLANG_RETURN_ON_FAIL(loadModuleLibrary((const Byte*)blob->getBufferPointer(), blob->getBufferSize(), req, library)); - - if (Artifact::canKeep(keep)) - { - product->add(Artifact::Entry::Style::Artifact, library); - } - - outLibrary = library; - return SLANG_OK; -} - -} // namespace Slang diff --git a/source/slang/slang-artifact.h b/source/slang/slang-artifact.h deleted file mode 100644 index 0e009e990..000000000 --- a/source/slang/slang-artifact.h +++ /dev/null @@ -1,370 +0,0 @@ -// slang-artifact.h -#ifndef SLANG_ARTIFACT_H -#define SLANG_ARTIFACT_H - -#include "slang-compiler.h" - -namespace Slang -{ - -enum class ArtifactKind : uint8_t -{ - None, ///< There is no container - - Unknown, ///< There is a container of unknown type - - Library, ///< Library of object code (typically made up multiple ObjectCode) - ObjectCode, ///< Object code (for CPU typically .o or .obj file types) - - Executable, ///< Self contained such it can exectuted. On GPU this would be a kernel. - SharedLibrary, ///< Shared library/dll - Callable, ///< Callable directly (typically means there isn't a binary artifact) - - Text, ///< Text - - Container, ///< A container holding other things - - CountOf, -}; - -enum class ArtifactPayload : uint8_t -{ - None, ///< There is no payload - - Unknown, ///< Has payload but its unknown variety - - DXIL, - DXBC, - SPIRV, - PTX, - - DXILAssembly, - DXBCAssembly, - SPIRVAssembly, - PTXAssembly, - - HostCPU, ///< The host CPU architecture - - SlangIR, ///< Slang IR - LLVMIR, ///< LLVM IR - - SlangAST, ///< Slang AST - - X86, - X86_64, - AARCH, - AARCH64, - - HLSL, ///< HLSL - GLSL, ///< GLSL - CPP, ///< C++ - C, ///< C Language - CUDA, ///< CUDA - Slang, ///< Slang - - DebugInfo, ///< Debug information - - Zip, ///< It's a zip - - CountOf, -}; - -enum class ArtifactStyle : uint8_t -{ - Unknown, ///< Unknown - - Kernel, ///< Compiled as `GPU kernel` style. - Host, ///< Compiled in `host` style - - CountOf, -}; - -typedef uint8_t ArtifactFlags; -struct ArtifactFlag -{ - enum Enum : ArtifactFlags - { - // Don't currently have any flags - }; -}; - - -/** -A value type to describe aspects of the contents of an Artifact. -**/ -struct ArtifactDesc -{ -public: - typedef ArtifactDesc This; - - typedef ArtifactKind Kind; - typedef ArtifactPayload Payload; - typedef ArtifactStyle Style; - typedef ArtifactFlags Flags; - - typedef uint32_t PackedBacking; - enum class Packed : PackedBacking; - - /// Get in packed format - inline Packed getPacked() const; - - /// True if the container appears to be binary linkable - bool isBinaryLinkable() const; - /// True if is a CPU binary - bool isCpuBinary() const { return isPayloadCpuBinary(payload); } - /// True if is a GPU binary - bool isGpuBinary() const { return isPayloadGpuBinary(payload); } - - /// Gets the default file extension for the artifact type. Returns empty slice if not known - UnownedStringSlice getDefaultExtension(); - - static UnownedStringSlice getDefaultExtensionForPayload(Payload payload); - - /// Get the extension for CPU/Host for a kind - static UnownedStringSlice getCpuExtensionForKind(Kind kind); - - /// Returns true if the kind is binary linkable - static bool isKindBinaryLinkable(Kind kind); - - /// Returns true if the payload type is CPU - static bool isPayloadCpuBinary(Payload payload); - /// Returns true if the payload type is applicable to the GPU - static bool isPayloadGpuBinary(Payload payload); - - /// True if the payload type is in principal binary linkable - static bool isPayloadGpuBinaryLinkable(Payload payload); - - /// Try to determine the desc from a path - static This fromPath(const UnownedStringSlice& slice); - /// Try to determine the desc from just a file extension (passed without .) - static This fromExtension(const UnownedStringSlice& slice); - - bool operator==(const This& rhs) const { return kind == rhs.kind && payload == rhs.payload && style == rhs.style && flags == rhs.flags; } - bool operator!=(const This& rhs) const { return !(*this == rhs); } - - /// Given a code gen target, get the equivalent ArtifactDesc - static This make(CodeGenTarget target); - - /// Construct from the elements - static This make(Kind inKind, Payload inPayload, Style inStyle = Style::Kernel, Flags flags = 0) - { - return This{ inKind, inPayload, inStyle, flags }; - } - /// Construct from the packed format - inline static This make(Packed inPacked); - - Kind kind; - Payload payload; - Style style; - Flags flags; -}; - -// -------------------------------------------------------------------------- -inline ArtifactDesc::Packed ArtifactDesc::getPacked() const -{ - typedef PackedBacking IntType; - return Packed((IntType(kind) << 24) | - (IntType(payload) << 16) | - (IntType(style) << 8) | - flags); -} - -// -------------------------------------------------------------------------- -inline /* static */ArtifactDesc ArtifactDesc::make(Packed inPacked) -{ - const PackedBacking packed = PackedBacking(inPacked); - - This r; - r.kind = Kind(packed >> 24); - r.payload = Payload(uint8_t(packed >> 16)); - r.style = Style(uint8_t(packed >> 8)); - r.flags = uint8_t(packed); - - return r; -} - -/* The Artifact type is a type designed to represent some Artifact of compilation. It could be input to or output from a compilation. - -An abstraction is desirable here, because depending on the compiler the artifact/s could be - -* A file on the file system -* A blob -* Multiple files -* Some other (perhaps multiple) in memory representations - -The artifact uses the Blob as the standard representation of in memory data. - -Some downstream compilers require the artifact to be available as a file system file, or to produce -artifacts that are files. The Artifact type allows to abstract away this difference, including the -ability to turn an in memory representation into a temporary file on the system file. - -The mechanism also allows for 'Containers' which allow for Artifacts to contain other Artifacts (amongst other things). -Those artifacts may be other files. For example a downstream compilation that produces results as well as temporary -files could be a Container containing artifacts for - -* Diagnostics -* Temporary files (of known and unknown types) -* Files that contain known types -* Callable interface (an ISlangSharedLibrary) - -A more long term goal would be to - -* Make Artifact an interface (such that it can work long term over binary boundaries) -* Make Diagnostics into an interface (such it can be added to a Artifact result) -* Use Artifact and related types for downstream compiler -*/ -class Artifact : public RefObject -{ -public: - - typedef ArtifactDesc Desc; - - typedef ArtifactKind Kind; - typedef ArtifactPayload Payload; - typedef ArtifactStyle Style; - typedef ArtifactFlags Flags; - - // Controls what items can be kept. - enum class Keep - { - No, ///< Don't keep the item - Yes, ///< Yes keep the final item - All, ///< Keep the final item and any intermediataries - }; - - enum PathType - { - None, - Temporary, - Existing, - }; - - /* A compile product can be made up of multiple representations. - */ - struct Entry - { - /// NOTE! Only interface innstances work across dll/shared library boundaries - /// because casting other types does not work across those boundaries. - - // The Type of the entry - enum class Type : uint8_t - { - InterfaceInstance, ///< An interface instance - ObjectInstance, ///< An object instance - RawInstance, - }; - enum class Style : uint8_t - { - Artifact, ///< Means this entry *can* represent the whole artifact - Child, ///< Some part of the artifact - Info, ///< Informational - Other, ///< Other - }; - - Type type; - Style style; - union - { - RefObject* object; - ISlangUnknown* intf; - void* raw; - }; - }; - - /// Given a type T find the associated instance - template - T* findObjectInstance(); - - /// Finds an instance of that has the guid. - ISlangUnknown* findInterfaceInstance(const Guid& guid); - - /// Returns true if the artifact in principal exists (it could be invalid) - bool exists() const; - - /// Load as a blob - SlangResult loadBlob(Keep keep, ComPtr& outBlob); - - /// Get as a file. May need to serialize and write as a temporary file. - SlangResult requireFilePath(Keep keep, String& outPath); - - SLANG_FORCE_INLINE const Desc& getDesc() { return m_desc; } - - /// Returns the index of the entry - Index indexOf(Entry::Type type) const; - - /// Add items - void setPath(PathType pathType, const String& filePath) { m_pathType = pathType; m_path = filePath; } - void setBlob(ISlangBlob* blob) { m_blob = blob; } - - void add(Entry::Style style, RefObject* obj); - void add(Entry::Style style, ISlangUnknown* intf); - - PathType getPathType() const { return m_pathType; } - const String& getPath() const { return m_path; } - - const List& getEntries() const { return m_entries; } - - /// True if can keep an intermediate item - static bool canKeepIntermediate(Keep keep) { return keep == Keep::All; } - /// True if can keep - static bool canKeep(Keep keep) { return Index(keep) >= Index(Keep::Yes); } - - /// Returns the keep type for an intermediate - static Keep getIntermediateKeep(Keep keep) { return (keep == Keep::All) ? Keep::All : Keep::No; } - - /// Ctor - Artifact(const Desc& desc) :m_desc(desc) {} - /// Dtor - ~Artifact(); - -protected: - Desc m_desc; - - PathType m_pathType = PathType::None; ///< What the path indicates - String m_path; ///< The path - - ComPtr m_blob; ///< Blob to store result in memory - - List m_entries; -}; - -// ---------------------------------------------------------------------- -template -T* Artifact::findObjectInstance() -{ - RefObject* check = static_cast(nullptr); - SLANG_UNUSED(check); - - // Check if we already have it - for (const auto& entry : m_entries) - { - if (entry.type == Entry::Type::ObjectInstance) - { - auto obj = as(entry.object); - if (obj) - { - return obj; - } - } - } - return nullptr; -} - - -// Class to hold information serialized in from a -r slang-lib/slang-module -class ModuleLibrary : public RefObject -{ -public: - - List m_entryPoints; - List> m_modules; -}; - -SlangResult loadModuleLibrary(const Byte* inBytes, size_t bytesCount, EndToEndCompileRequest* req, RefPtr& module); - -// Given a product make available as a module -SlangResult loadModuleLibrary(Artifact::Keep keep, Artifact* artifact, EndToEndCompileRequest* req, RefPtr& module); - -} // namespace Slang - -#endif diff --git a/source/slang/slang-compiler.cpp b/source/slang/slang-compiler.cpp index 881194bcb..789103ff8 100644 --- a/source/slang/slang-compiler.cpp +++ b/source/slang/slang-compiler.cpp @@ -1285,7 +1285,13 @@ void printDiagnosticArg(StringBuilder& sb, CodeGenTarget val) if (_isCPUHostTarget(target)) { options.libraryPaths.add(Path::getParentDirectory(Path::getExecutablePath())); - options.libraries.add("slang-rt"); + + // Set up the library artifact + const ArtifactDesc desc = ArtifactDesc::make(ArtifactKind::Library, Artifact::Payload::HostCPU, ArtifactStyle::Unknown); + RefPtr artifact = new Artifact(desc); + artifact->setPath(Artifact::PathType::Existing, "slang-rt"); + + options.libraries.add(artifact); } } @@ -1386,6 +1392,9 @@ void printDiagnosticArg(StringBuilder& sb, CodeGenTarget val) options.defines.add(define); } } + + // Add all of the module libraries + options.libraries.addRange(linkage->m_libModules.getBuffer(), linkage->m_libModules.getCount()); } // Compile diff --git a/source/slang/slang-emit-hlsl.cpp b/source/slang/slang-emit-hlsl.cpp index 059a3f641..03566f9df 100644 --- a/source/slang/slang-emit-hlsl.cpp +++ b/source/slang/slang-emit-hlsl.cpp @@ -739,14 +739,11 @@ void HLSLSourceEmitter::emitFuncDecorationImpl(IRDecoration* decoration) const auto stage = profile.getStage(); const auto version = profile.getVersion(); - // I would perhaps ideally know that this was being compiled for 'library' stage. - // Stage::Unknown is currently also used for lib profiles. - - // TODO(JS): Potentially can do export for fxc too, but for now we don't add. - - if (family == ProfileFamily::DX && - version >= ProfileVersion::DX_6_1 && - stage == Stage::Unknown) + // If it's whole program and it's for a late enough version of shader model + // output with 'export' + if (getTargetReq()->isWholeProgramRequest() && + family == ProfileFamily::DX && + version >= ProfileVersion::DX_6_1) { m_writer->emit("export\n"); } diff --git a/source/slang/slang-ir-link.cpp b/source/slang/slang-ir-link.cpp index b03d48764..fd91d81bb 100644 --- a/source/slang/slang-ir-link.cpp +++ b/source/slang/slang-ir-link.cpp @@ -6,7 +6,10 @@ #include "slang-ir-insts.h" #include "slang-mangle.h" #include "slang-ir-string-hash.h" -#include "slang-artifact.h" + +#include "slang-module-library.h" + +#include "../compiler-core/slang-artifact.h" namespace Slang { diff --git a/source/slang/slang-module-library.cpp b/source/slang/slang-module-library.cpp new file mode 100644 index 000000000..76bb85ebb --- /dev/null +++ b/source/slang/slang-module-library.cpp @@ -0,0 +1,95 @@ +// slang-module-library.cpp +#include "slang-module-library.h" +#include + +#include "../core/slang-blob.h" +#include "../core/slang-riff.h" + +#include "../core/slang-type-text-util.h" + +// Serialization +#include "slang-serialize-ir.h" +#include "slang-serialize-container.h" + +namespace Slang { + + +SlangResult loadModuleLibrary(const Byte* inBytes, size_t bytesCount, EndToEndCompileRequest* req, RefPtr& outLibrary) +{ + RefPtr library = new ModuleLibrary; + + // Load up the module + MemoryStreamBase memoryStream(FileAccess::Read, inBytes, bytesCount); + + RiffContainer riffContainer; + SLANG_RETURN_ON_FAIL(RiffUtil::read(&memoryStream, riffContainer)); + + auto linkage = req->getLinkage(); + + // TODO(JS): May be better to have a ITypeComponent that encapsulates a collection of modules + // For now just add to the linkage + + { + SerialContainerData containerData; + + SerialContainerUtil::ReadOptions options; + options.namePool = req->getNamePool(); + options.session = req->getSession(); + options.sharedASTBuilder = linkage->getASTBuilder()->getSharedASTBuilder(); + options.sourceManager = linkage->getSourceManager(); + options.linkage = req->getLinkage(); + options.sink = req->getSink(); + + SLANG_RETURN_ON_FAIL(SerialContainerUtil::read(&riffContainer, options, containerData)); + + for (const auto& module : containerData.modules) + { + // If the irModule is set, add it + if (module.irModule) + { + library->m_modules.add(module.irModule); + } + } + + for (const auto& entryPoint : containerData.entryPoints) + { + FrontEndCompileRequest::ExtraEntryPointInfo dst; + dst.mangledName = entryPoint.mangledName; + dst.name = entryPoint.name; + dst.profile = entryPoint.profile; + + // Add entry point + library->m_entryPoints.add(dst); + } + } + + outLibrary = library; + return SLANG_OK; +} + +SlangResult loadModuleLibrary(ArtifactKeep keep, Artifact* product, EndToEndCompileRequest* req, RefPtr& outLibrary) +{ + if (auto foundLibrary = product->findObjectInstance()) + { + outLibrary = foundLibrary; + return SLANG_OK; + } + + // Load the blob + ComPtr blob; + SLANG_RETURN_ON_FAIL(product->loadBlob(getIntermediateKeep(keep), blob)); + + // Load the module + RefPtr library; + SLANG_RETURN_ON_FAIL(loadModuleLibrary((const Byte*)blob->getBufferPointer(), blob->getBufferSize(), req, library)); + + if (canKeep(keep)) + { + product->add(Artifact::Entry::Style::Artifact, library); + } + + outLibrary = library; + return SLANG_OK; +} + +} // namespace Slang diff --git a/source/slang/slang-module-library.h b/source/slang/slang-module-library.h new file mode 100644 index 000000000..dc709a684 --- /dev/null +++ b/source/slang/slang-module-library.h @@ -0,0 +1,28 @@ +// slang-module-library.h +#ifndef SLANG_MODULE_LIBRARY_H +#define SLANG_MODULE_LIBRARY_H + +#include "../compiler-core/slang-artifact.h" + +#include "slang-compiler.h" + +namespace Slang +{ + +// Class to hold information serialized in from a -r slang-lib/slang-module +class ModuleLibrary : public RefObject +{ +public: + + List m_entryPoints; + List> m_modules; +}; + +SlangResult loadModuleLibrary(const Byte* inBytes, size_t bytesCount, EndToEndCompileRequest* req, RefPtr& module); + +// Given a product make available as a module +SlangResult loadModuleLibrary(ArtifactKeep keep, Artifact* artifact, EndToEndCompileRequest* req, RefPtr& module); + +} // namespace Slang + +#endif diff --git a/source/slang/slang-options.cpp b/source/slang/slang-options.cpp index d4199154f..4c7234753 100644 --- a/source/slang/slang-options.cpp +++ b/source/slang/slang-options.cpp @@ -9,7 +9,8 @@ #include "slang-compiler.h" #include "slang-profile.h" -#include "slang-artifact.h" + +#include "../compiler-core/slang-artifact.h" #include "slang-repro.h" #include "slang-serialize-ir.h" diff --git a/source/slang/slang.cpp b/source/slang/slang.cpp index 5d4e61cc0..5b65cd15a 100644 --- a/source/slang/slang.cpp +++ b/source/slang/slang.cpp @@ -7,7 +7,9 @@ #include "../core/slang-type-text-util.h" #include "../core/slang-type-convert-util.h" -#include "slang-artifact.h" +#include "../compiler-core/slang-artifact.h" + +#include "slang-module-library.h" #include "slang-check.h" #include "slang-parameter-binding.h" @@ -4335,7 +4337,7 @@ SlangResult _addLibraryReference(EndToEndCompileRequest* req, Artifact* artifact { RefPtr library; - SLANG_RETURN_ON_FAIL(loadModuleLibrary(Artifact::Keep::Yes, artifact, req, library)); + SLANG_RETURN_ON_FAIL(loadModuleLibrary(ArtifactKeep::Yes, artifact, req, library)); FrontEndCompileRequest* frontEndRequest = req->getFrontEndReq(); frontEndRequest->m_extraEntryPoints.addRange(library->m_entryPoints.getBuffer(), library->m_entryPoints.getCount()); -- cgit v1.2.3