From ef08bdaf501982ae24a73200e55f99157e4b7e6a Mon Sep 17 00:00:00 2001
From: jsmall-nvidia <jsmall@nvidia.com>
Date: Fri, 8 Feb 2019 11:41:26 -0500
Subject: Hotfix/dispatch thread id improvements (#834)

* * Make vector comparisons out correct functions on glsl
* Test for vector comparisons
* Typo fixes

* Glsl vector comparisons use functions.

* Added a coercion test.

* Do checking for the SV_DispatchThreadId type to see if it appears valid.

* Fix typo

* Make glsl do type conversion for SV_DispatchThreadID parameter.

* Fix glsl to match func-resource-param-array with changes to how SV_DispatchThreadID changes.
---
 source/slang/check.cpp            | 62 +++++++++++++++++++++++++++++++++++++++
 source/slang/diagnostic-defs.h    |  4 ++-
 source/slang/ir-glsl-legalize.cpp |  5 +++-
 3 files changed, 69 insertions(+), 2 deletions(-)

(limited to 'source')

diff --git a/source/slang/check.cpp b/source/slang/check.cpp
index cce6a545a..8dfd7e640 100644
--- a/source/slang/check.cpp
+++ b/source/slang/check.cpp
@@ -9228,6 +9228,40 @@ namespace Slang
         return entryPointFuncDecl;
     }
 
+    static bool isValidThreadDispatchIDType(Type* type)
+    {
+        // Can accept a single int/unit
+        {
+            auto basicType = as<BasicExpressionType>(type);
+            if (basicType)
+            {
+                return (basicType->baseType == BaseType::Int || basicType->baseType == BaseType::UInt);
+            }
+        }
+        // Can be an int/uint vector from size 1 to 3
+        {
+            auto vectorType = as<VectorExpressionType>(type);
+            if (!vectorType)
+            {
+                return false;
+            }
+            auto elemCount = as<ConstantIntVal>(vectorType->elementCount);
+            if (elemCount->value < 1 || elemCount->value > 3)
+            {
+                return false;
+            }
+            // Must be a basic type
+            auto basicType = as<BasicExpressionType>(vectorType->elementType);
+            if (!basicType)
+            {
+                return false;
+            }
+
+            // Must be integral
+            return (basicType->baseType == BaseType::Int || basicType->baseType == BaseType::UInt);
+        }
+    }
+
     // Validate that an entry point function conforms to any additional
     // constraints based on the stage (and profile?) it specifies.
     void validateEntryPoint(
@@ -9303,6 +9337,34 @@ namespace Slang
                 attr->patchConstantFuncDecl = funcDecl;
             }
         }
+        else if (entryPoint->getStage() == Stage::Compute)
+        {
+            auto funcDecl = entryPoint->getFuncDecl();
+
+            auto params = funcDecl->GetParameters();
+
+            for (const auto& param : params)
+            {
+                if (auto semantic = param->FindModifier<HLSLSimpleSemantic>())
+                {
+                    const auto& semanticToken = semantic->name;
+
+                    String lowerName = String(semanticToken.Content).ToLower();
+
+                    if (lowerName == "sv_dispatchthreadid")
+                    {
+                        Type* paramType = param->getType();
+
+                        if (!isValidThreadDispatchIDType(paramType))
+                        {
+                            String typeString = paramType->ToString();
+                            sink->diagnose(param->loc, Diagnostics::invalidDispatchThreadIDType, typeString);
+                            return;
+                        }
+                    }
+                }
+            }
+        }
     }
 
     // Given an `EntryPointRequest` specified via API or command line options,
diff --git a/source/slang/diagnostic-defs.h b/source/slang/diagnostic-defs.h
index 9a8446a03..3e9d9043c 100644
--- a/source/slang/diagnostic-defs.h
+++ b/source/slang/diagnostic-defs.h
@@ -351,12 +351,14 @@ DIAGNOSTIC(38021, Error, typeArgumentDoesNotConformToInterface, "type argument `
 
 DIAGNOSTIC(38022, Error, cannotSpecializeGlobalGenericToItself, "the global type parameter '$0' cannot be specialized to itself")
 DIAGNOSTIC(38023, Error, cannotSpecializeGlobalGenericToAnotherGenericParam, "the global type parameter '$0' cannot be specialized using another global type parameter ('$1')")
+
+DIAGNOSTIC(38024, Error, invalidDispatchThreadIDType, "parameter with SV_DispatchThreadID must be either scalar or vector (1 to 3) of uint/int but is $0");
+
 DIAGNOSTIC(-1, Note, noteWhenCompilingEntryPoint, "when compiling entry point '$0'")
 
 DIAGNOSTIC(38200, Error, recursiveModuleImport, "module `$0` recursively imports itself")
 DIAGNOSTIC(39999, Fatal, errorInImportedModule, "error in imported module, compilation ceased.")
 
-
 // 39xxx - Type layout and parameter binding.
 
 DIAGNOSTIC(39000, Error, conflictingExplicitBindingsForParameter, "conflicting explicit bindings for parameter '$0'")
diff --git a/source/slang/ir-glsl-legalize.cpp b/source/slang/ir-glsl-legalize.cpp
index 5b60314eb..57d493f1a 100644
--- a/source/slang/ir-glsl-legalize.cpp
+++ b/source/slang/ir-glsl-legalize.cpp
@@ -304,6 +304,9 @@ GLSLSystemValueInfo* getGLSLSystemValueInfo(
     else if(semanticName == "sv_dispatchthreadid")
     {
         name = "gl_GlobalInvocationID";
+
+        auto builder = context->getBuilder();
+        requiredType = builder->getVectorType(builder->getBasicType(BaseType::UInt), builder->getIntValue(builder->getIntType(), 3));
     }
     else if(semanticName == "sv_domainlocation")
     {
@@ -514,7 +517,7 @@ ScalarizedVal createSimpleGLSLGlobalVarying(
     //
     // Our IR global shader parameters are read-only, just
     // like our IR function parameters, and need a wrapper
-    // `Out<...>` type to represent otuputs.
+    // `Out<...>` type to represent outputs.
     //
     bool isOutput = kind == LayoutResourceKind::VaryingOutput;
     IRType* paramType = isOutput ? builder->getOutType(type) : type;
-- 
cgit v1.2.3