Support derivative functions in compute & capabilities adjustments (#4014)

* Support derivative functions in compute & capabilities adjustments

fixes #4000

PR implements derivative functions in compute shaders properly so we have the functionality for SPIR-V & GLSL. Tests reflect fragment and compute paths.

PR also adjusts capabilities to correct wrong SPRI-V target capabilities for when using textures.

Remarks:
1. __requireComputeDerivative(); is a intrinsic_op and not modifier since inlining will destroy the modifier.
2. Derivative mode is tied to an entry point decoration `[DerivativeGroupQuad]`/`[DerivativeGroupLinear]` or GLSL syntax ``derivative_group_linearNV`. Default is to set the mode to `[DerivativeGroupQuad]`

* remove -emit-spirv-directly

* fixes

1. fix minor issue fwidth change where I returned the wrong type
2. fix issue where glslang{glsl->spirv} is wrong, so we don't run that test and just run the glsl test & direct spir-v test for intrinsic-texture.slang

* adjust as per review and refine code

1. add test to ensure multi-diverging-in-logic entry points work -- 2 functions which may cause computeDerivatives + 1 that uses, 1 that does not.
2. naming
3. use entry point ref graph for c-like-targets
4. reordered some code to util's and removed `static linline` since that was just for ease of coding on my end (should not have been pushed).

* Grammer

* split up source file + issolate GLSL emit path change.

---------

Co-authored-by: Yong He <yonghe@outlook.com>

1 files changed, 37 insertions, 1 deletions

diff --git a/source/slang/slang-emit-glsl.cpp b/source/slang/slang-emit-glsl.cpp
index 32301c418..d768cff97 100644
--- a/source/slang/slang-emit-glsl.cpp
+++ b/source/slang/slang-emit-glsl.cpp
@@ -10,6 +10,7 @@
 #include "slang-legalize-types.h"
 #include "slang-ir-layout.h"
 #include "slang/slang-ir.h"
+#include "slang-ir-call-graph.h"
 
 #include <assert.h>
 
@@ -26,6 +27,11 @@ GLSLSourceEmitter::GLSLSourceEmitter(const Desc& desc) :
     SLANG_ASSERT(m_glslExtensionTracker);
 }
 
+void GLSLSourceEmitter::beforeComputeEmitActions(IRModule* module)
+{
+    buildEntryPointReferenceGraph(this->m_referencingEntryPoints, module);
+}
+
 SlangResult GLSLSourceEmitter::init()
 {
     SLANG_RETURN_ON_FAIL(Super::init());
@@ -2171,7 +2177,7 @@ void GLSLSourceEmitter::handleRequiredCapabilitiesImpl(IRInst* inst)
         }
     }
 
-    // The function may have IRRequireGLSLExtensionInst in its body. We also need to look for them.
+    // The function may have various requirment declaring functions its body. We also need to look for them.
     auto func = as<IRFunc>(inst);
     if (!func)
         return;
@@ -2184,6 +2190,36 @@ void GLSLSourceEmitter::handleRequiredCapabilitiesImpl(IRInst* inst)
         {
             _requireGLSLExtension(requireGLSLExt->getExtensionName());
         }
+        else if (auto requireComputeDerivative = as<IRRequireComputeDerivative>(childInst))
+        {
+            // only allowed 1 of derivative_group_quadsNV or derivative_group_linearNV
+            if (m_entryPointStage != Stage::Compute
+                || m_requiredPreludesRaw.contains("layout(derivative_group_quadsNV) in;")
+                || m_requiredPreludesRaw.contains("layout(derivative_group_linearNV) in;")
+                )
+                return;
+
+            _requireGLSLExtension(UnownedStringSlice("GL_NV_compute_shader_derivatives"));
+
+            // This will only run once per program.
+            HashSet<IRFunc*>* entryPointsUsingInst = getReferencingEntryPoints(m_referencingEntryPoints, func);
+
+            for (auto entryPoint : *entryPointsUsingInst)
+            {
+                bool isQuad = !entryPoint->findDecoration<IRDerivativeGroupLinearDecoration>();
+                auto numThreadsDecor = entryPoint->findDecoration<IRNumThreadsDecoration>();
+                if (isQuad)
+                {
+                    verifyComputeDerivativeGroupModifiers(getSink(), inst->sourceLoc, true, false, numThreadsDecor);
+                    m_requiredPreludesRaw.add("layout(derivative_group_quadsNV) in;");
+                }
+                else
+                {
+                    verifyComputeDerivativeGroupModifiers(getSink(), inst->sourceLoc, false, true, numThreadsDecor);
+                    m_requiredPreludesRaw.add("layout(derivative_group_linearNV) in;");
+                }
+            }
+        }
     }
 }