Add unit test for entry point lookup bug

See issue #4760.

Author: aleino-nv

tools/slang-unit-test/unit-test-entry-point-options.cpp

@@ -0,0 +1,102 @@
+#include "../../source/core/slang-process.h"
+#include "slang-com-ptr.h"
+#include "slang.h"
+#include "unit-test/slang-unit-test.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+using namespace Slang;
+
+// Make sure that we can look up entry points that are not explicitly marked out using e.g.
+// [shader("fragment")], but rather specified as entry points via the
+// CompilerOptionName::EntryPointName API option.
+
+SLANG_UNIT_TEST(entryPointOptions)
+{
+
+    char const* const sourceString =
+        R"(
+        float4 vertexMain() : SV_Position
+        {
+            return float4(0,0,0,1);
+        }
+
+        float4 fragmentMain() : SV_Target
+        {
+            return float4(1,1,1,1);
+        })";
+    Slang::String source(sourceString);
+
+    ComPtr<slang::IGlobalSession> globalSession;
+    SlangResult res = slang::createGlobalSession(globalSession.writeRef());
+    SLANG_CHECK(SLANG_SUCCEEDED(res));
+
+    List<slang::CompilerOptionEntry> vertexTargetOptionEntries;
+    {
+        slang::CompilerOptionEntry entry;
+        entry.name = slang::CompilerOptionName::Stage;
+        entry.value.kind = slang::CompilerOptionValueKind::Int;
+        entry.value.intValue0 = int(SlangStage::SLANG_STAGE_VERTEX);
+        vertexTargetOptionEntries.add(entry);
+    }
+    {
+        slang::CompilerOptionEntry entry;
+        entry.name = slang::CompilerOptionName::EntryPointName;
+        entry.value.kind = slang::CompilerOptionValueKind::String;
+        entry.value.stringValue0 = "vertexMain";
+        vertexTargetOptionEntries.add(entry);
+    }
+    List<slang::CompilerOptionEntry> fragmentTargetOptionEntries;
+    {
+        slang::CompilerOptionEntry entry;
+        entry.name = slang::CompilerOptionName::Stage;
+        entry.value.kind = slang::CompilerOptionValueKind::Int;
+        entry.value.intValue0 = int(SlangStage::SLANG_STAGE_FRAGMENT);
+        fragmentTargetOptionEntries.add(entry);
+    }
+    {
+        slang::CompilerOptionEntry entry;
+        entry.name = slang::CompilerOptionName::EntryPointName;
+        entry.value.kind = slang::CompilerOptionValueKind::String;
+        entry.value.stringValue0 = "fragmentMain";
+        fragmentTargetOptionEntries.add(entry);
+    }
+    List<slang::TargetDesc> targetDescs;
+    {
+        slang::TargetDesc targetDesc = {};
+        targetDesc.format = SlangCompileTarget::SLANG_HLSL;
+        targetDesc.compilerOptionEntries = vertexTargetOptionEntries.getBuffer();
+        targetDesc.compilerOptionEntryCount = vertexTargetOptionEntries.getCount();
+        targetDescs.add(targetDesc);
+    }
+    {
+        slang::TargetDesc targetDesc = {};
+        targetDesc.format = SlangCompileTarget::SLANG_HLSL;
+        targetDesc.compilerOptionEntries = fragmentTargetOptionEntries.getBuffer();
+        targetDesc.compilerOptionEntryCount = fragmentTargetOptionEntries.getCount();
+        targetDescs.add(targetDesc);
+    }
+    slang::SessionDesc sessionDesc = {};
+    sessionDesc.targetCount = targetDescs.getCount();
+    sessionDesc.targets = targetDescs.getBuffer();
+    const char* entryPointNames[] = {"vertexMain", "fragmentMain"};
+    ComPtr<slang::ISession> session;
+    res = globalSession->createSession(sessionDesc, session.writeRef());
+    SLANG_CHECK(SLANG_SUCCEEDED(res));
+    ComPtr<slang::IBlob> diagnostics;
+    ComPtr<slang::IModule> module(session->loadModuleFromSourceString(
+        "main",
+        "main.slang",
+        source.getBuffer(),
+        diagnostics.writeRef()));
+    SLANG_CHECK(module != nullptr);
+
+    for (const char* name : entryPointNames)
+    {
+        ComPtr<slang::IEntryPoint> entryPoint;
+        res = module->findEntryPointByName(name, entryPoint.writeRef());
+        SLANG_CHECK(SLANG_SUCCEEDED(res));
+        SLANG_CHECK(entryPoint != nullptr);
+    }
+}