Add support for global generic parameters (shader-slang#285)

* Add support for global generic parameters
(In-progress work)

This commit include:
1.  Update Slang API to allow specification of generic type arguments in an `EntryPointRequest`
2. Add parsing of `__generic_param` construct, which becomes a GlobalGenericParamDecl, contains members of `GenericTypeConstraintDecl`.
3. Semantics checking will check whether the provided type arguments conform to the interfaces as defined by the generic parameter, and store SubtypeWitness values in the EntryPointRequest, which will be used by `specializeIRForEntryPoint` when generating final IR.
4. Add a new type of substitution - `GlobalGenericParamSubstitution` for subsittuting references to `__generic_param` decls or to its member `GenericTypeConsraintDecl` with the actual type argument or witness tables.
5. Update `IRSpecContext` to apply `GlobalGenericParamSubstitution` when specializing the IR for an EntryPointRequest.
6. Update `render-test` to take additional `type` inputs, which specifies the type arguments to substitute into the global `__generic_param` types.

This commit does not include ProgramLayout specialization.

* IR: pass through `[unroll]` attribute (shader-slang#284)

The initial lowering was adding an `IRLoopControlDecoration` to the instruction at the head of a loop, but this was getting dropped when the IR gets cloned for a particular entry point.
The fix was simply to add a case for loop-control decorations to `cloneDecoration`.

* fix warnings

* IR: support `CompileTimeForStmt` (shader-slang#286)

This statement type is a bit of a hack, to support loops that *must* be unrolled.
The AST-to-AST pass handles them by cloning the AST for the loop body N times, and it was easy enough to do the same thing for the IR: emit the instructions for the body N times.
The only thing that requires a bit of care is that now we might see the same variable declarations multiple times, so we need to play it safe and overwrite existing entries in our map from declarations to their IR values.

Of course a better answer long-term would be to do the actual unrolling in the IR. This is especially true because we might some day want to support compile-time/must-unroll loops in functions, where the loop counter comes in as a parameter (but must still be compile-time-constant at every call site).

* Add support for global generic parameters
(In-progress work)

This commit include:
1.  Update Slang API to allow specification of generic type arguments in an `EntryPointRequest`
2. Add parsing of `__generic_param` construct, which becomes a GlobalGenericParamDecl, contains members of `GenericTypeConstraintDecl`.
3. Semantics checking will check whether the provided type arguments conform to the interfaces as defined by the generic parameter, and store SubtypeWitness values in the EntryPointRequest, which will be used by `specializeIRForEntryPoint` when generating final IR.
4. Add a new type of substitution - `GlobalGenericParamSubstitution` for subsittuting references to `__generic_param` decls or to its member `GenericTypeConsraintDecl` with the actual type argument or witness tables.
5. Update `IRSpecContext` to apply `GlobalGenericParamSubstitution` when specializing the IR for an EntryPointRequest.
6. Update `render-test` to take additional `type` inputs, which specifies the type arguments to substitute into the global `__generic_param` types.

progress on parameter binding

* Add a more contrived test case for specializing parameter bindings

* update render-test to align buffers to 256 bytes (to get rid of D3D complains on minimal buffer size).

* adding one more test case for parameter binding specialization.

* Cleanup according to @tfoleyNV 's suggestions.

* fix a bug introduced in the cleanup

Author: csyonghe

slang.h

@@ -377,6 +377,18 @@ extern "C"
         char const*             name,
         SlangProfileID          profile);
 
+    /** Add an entry point in a particular translation unit,
+        with additional arguments that specify the concrete
+        type names for global generic type parameters.
+    */
+    SLANG_API int spAddEntryPointEx(
+        SlangCompileRequest*    request,
+        int                     translationUnitIndex,
+        char const*             name,
+        SlangProfileID          profile,
+        int                     genericTypeNameCount,
+        char const**            genericTypeNames);
+
     /** Execute the compilation request.
 
     Returns zero on success, non-zero on failure.
@@ -588,6 +600,9 @@ extern "C"
         // HLSL register `space`, Vulkan GLSL `set`
         SLANG_PARAMETER_CATEGORY_REGISTER_SPACE,
 
+        // A parameter whose type is to be specialized by a global generic type argument
+        SLANG_PARAMETER_CATEGORY_GENERIC,
+
         //
         SLANG_PARAMETER_CATEGORY_COUNT,
     };
@@ -695,6 +710,8 @@ extern "C"
     SLANG_API SlangUInt spReflection_getEntryPointCount(SlangReflection* reflection);
 
     SLANG_API SlangReflectionEntryPoint* spReflection_getEntryPointByIndex(SlangReflection* reflection, SlangUInt index);
+    SLANG_API SlangUInt spReflection_getGlobalConstantBufferBinding(SlangReflection* reflection);
+    SLANG_API size_t spReflection_getGlobalConstantBufferSize(SlangReflection* reflection);
 
 #ifdef __cplusplus  
 }
@@ -848,6 +865,7 @@ namespace slang
         SpecializationConstant = SLANG_PARAMETER_CATEGORY_SPECIALIZATION_CONSTANT,
         PushConstantBuffer = SLANG_PARAMETER_CATEGORY_PUSH_CONSTANT_BUFFER,
         RegisterSpace = SLANG_PARAMETER_CATEGORY_REGISTER_SPACE,
+        GenericResource = SLANG_PARAMETER_CATEGORY_GENERIC,
     };
 
     struct TypeLayoutReflection
@@ -1102,6 +1120,16 @@ namespace slang
         {
             return (EntryPointReflection*) spReflection_getEntryPointByIndex((SlangReflection*) this, index);
         }
+
+        SlangUInt getGlobalConstantBufferBinding()
+        {
+            return spReflection_getGlobalConstantBufferBinding((SlangReflection*)this);
+        }
+
+        size_t getGlobalConstantBufferSize()
+        {
+            return spReflection_getGlobalConstantBufferSize((SlangReflection*)this);
+        }
     };
 }
 

source/core/list.h

@@ -487,7 +487,7 @@ namespace Slang
 				if (predicate(buffer[i]))
 					return i;
 			}
-			return -1;
+			return (UInt)-1;
 		}
 
 		template<typename Func>
@@ -498,7 +498,7 @@ namespace Slang
 				if (predicate(buffer[i-1]))
 					return i-1;
 			}
-			return -1;
+			return (UInt)-1;
 		}
 
 		template<typename T2>
@@ -509,7 +509,7 @@ namespace Slang
 				if (buffer[i] == val)
 					return i;
 			}
-			return -1;
+			return (UInt)-1;
 		}
 
 		template<typename T2>
@@ -520,7 +520,7 @@ namespace Slang
 				if(buffer[i-1] == val)
 					return i-1;
 			}
-			return -1;
+			return (UInt)-1;
 		}
 
 		void Sort()

source/slang/check.cpp

@@ -148,7 +148,6 @@ namespace Slang
                 return expr->type->As<DeclRefType>();
         }
 
-
         RefPtr<Expr> ConstructDeclRefExpr(
             DeclRef<Decl>   declRef,
             RefPtr<Expr>    baseExpr,
@@ -1998,6 +1997,22 @@ namespace Slang
             decl->SetCheckState(DeclCheckState::Checked);
         }
 
+        void visitGlobalGenericParamDecl(GlobalGenericParamDecl * decl)
+        {
+            if (decl->IsChecked(DeclCheckState::Checked)) return;
+            decl->SetCheckState(DeclCheckState::CheckedHeader);
+            // global generic param only allowed in global scope
+            auto program = decl->ParentDecl->As<ModuleDecl>();
+            if (!program)
+                getSink()->diagnose(decl, Slang::Diagnostics::globalGenParamInGlobalScopeOnly);
+            // Now check all of the member declarations.
+            for (auto member : decl->Members)
+            {
+                checkDecl(member);
+            }
+            decl->SetCheckState(DeclCheckState::Checked);
+        }
+
         void visitAssocTypeDecl(AssocTypeDecl* decl)
         {
             if (decl->IsChecked(DeclCheckState::Checked)) return;
@@ -3703,6 +3718,19 @@ namespace Slang
                             return true;
                         }
                     }
+                    // if an inheritance decl is not found, try to find a GenericTypeConstraintDecl
+                    for (auto genConstraintDeclRef : getMembersOfType<GenericTypeConstraintDecl>(aggTypeDeclRef))
+                    {
+                        EnsureDecl(genConstraintDeclRef.getDecl());
+                        auto inheritedType = GetSup(genConstraintDeclRef);
+                        TypeWitnessBreadcrumb breadcrumb;
+                        breadcrumb.prev = inBreadcrumbs;
+                        breadcrumb.declRef = genConstraintDeclRef;
+                        if (doesTypeConformToInterfaceImpl(originalType, inheritedType, interfaceDeclRef, outWitness, &breadcrumb))
+                        {
+                            return true;
+                        }
+                    }
                 }
                 else if( auto genericTypeParamDeclRef = declRef.As<GenericTypeParamDecl>() )
                 {
@@ -6582,6 +6610,78 @@ namespace Slang
         // that we don't have to re-do this effort again later.
         entryPoint->decl = entryPointFuncDecl;
 
+        // Lookup generic parameter types in global scope
+        for (auto name : entryPoint->genericParameterTypeNames)
+        {
+            if (!translationUnitSyntax->memberDictionary.TryGetValue(name, firstDeclWithName))
+            {
+                // If there doesn't appear to be any such declaration, then
+                // we need to diagnose it as an error, and then bail out.
+                sink->diagnose(translationUnitSyntax, Diagnostics::entryPointTypeParameterNotFound, name);
+                return;
+            }
+            RefPtr<Type> type;
+            if (auto aggType = firstDeclWithName->As<AggTypeDecl>())
+            {
+                type = DeclRefType::Create(entryPoint->compileRequest->mSession, DeclRef<Decl>(aggType, nullptr));
+            }
+            else if (auto typeDefDecl = firstDeclWithName->As<TypeDefDecl>())
+            {
+                type = GetType(DeclRef<TypeDefDecl>(typeDefDecl, nullptr));
+            }
+            else
+            {
+                sink->diagnose(firstDeclWithName, Diagnostics::entryPointTypeSymbolNotAType, name);
+                return;
+            }
+            entryPoint->genericParameterTypes.Add(type);
+        }
+        // check that user-provioded type arguments conforms to the generic type
+        // parameter declaration of this translation unit
+
+        // collect global generic parameters from all imported modules
+        List<RefPtr<GlobalGenericParamDecl>> globalGenericParams;
+        // add current translation unit first
+        {        
+            auto globalGenParams = translationUnit->SyntaxNode->getMembersOfType<GlobalGenericParamDecl>();
+            for (auto p : globalGenParams)
+                globalGenericParams.Add(p);
+        }
+        // add imported modules
+        for (auto moduleDecl : entryPoint->compileRequest->loadedModulesList)
+        {
+            auto globalGenParams = moduleDecl->getMembersOfType<GlobalGenericParamDecl>();
+            for (auto p : globalGenParams)
+                globalGenericParams.Add(p);
+        }
+        if (globalGenericParams.Count() != entryPoint->genericParameterTypes.Count())
+        {
+            sink->diagnose(entryPoint->decl, Diagnostics::mismatchEntryPointTypeArgument, globalGenericParams.Count(),
+                    entryPoint->genericParameterTypes.Count());
+            return;
+        }
+        // if number of entry-point type arguments matches parameters, try find
+        // SubtypeWitness for each argument
+        int index = 0;
+        for (auto & gParam : globalGenericParams)
+        {
+            for (auto constraint : gParam->getMembersOfType<GenericTypeConstraintDecl>())
+            {
+                auto interfaceType = GetSup(DeclRef<GenericTypeConstraintDecl>(constraint, nullptr));
+                SemanticsVisitor visitor(sink, entryPoint->compileRequest, translationUnit);
+                auto witness = visitor.tryGetSubtypeWitness(entryPoint->genericParameterTypes[index], interfaceType);
+                if (!witness)
+                {
+                    sink->diagnose(gParam,
+                        Diagnostics::typeArgumentDoesNotConformToInterface, gParam->nameAndLoc.name, entryPoint->genericParameterTypes[index],
+                        interfaceType);
+                }
+                entryPoint->genericParameterWitnesses.Add(witness);
+            }
+            index++;
+        }
+        if (sink->errorCount != 0)
+            return;
         // TODO: after all that work, we are now in a position to start
         // validating the declaration itself. E.g., we should check if
         // the declared input/output parameters have suitable semantics,

source/slang/compiler.cpp

@@ -11,7 +11,7 @@
 #include "parser.h"
 #include "preprocessor.h"
 #include "syntax-visitors.h"
-
+#include "type-layout.h"
 #include "reflection.h"
 #include "emit.h"
 
@@ -160,7 +160,7 @@ namespace Slang
                 entryPoint,
                 targetReq->layout.Ptr(),
                 CodeGenTarget::HLSL,
-                targetReq->target);
+                targetReq);
         }
     }
 
@@ -207,7 +207,7 @@ namespace Slang
                 entryPoint,
                 targetReq->layout.Ptr(),
                 CodeGenTarget::GLSL,
-                targetReq->target);
+                targetReq);
         }
     }
 

source/slang/compiler.h

@@ -100,6 +100,10 @@ namespace Slang
 
         // The name of the entry point function (e.g., `main`)
         Name* name;
+        
+        // The type names we want to substitute into the 
+        // global generic type parameters
+        List<Name*> genericParameterTypeNames;
 
         // The profile that the entry point will be compiled for
         // (this is a combination of the target state, and also
@@ -123,6 +127,11 @@ namespace Slang
         // it should not be assumed to be available in cases
         // where any errors were diagnosed.
         RefPtr<FuncDecl> decl;
+
+        // The declaration of the global generic parameter types
+        // This will be filled in as part of semantic analysis.
+        List<RefPtr<Type>> genericParameterTypes;
+        List<RefPtr<Val>> genericParameterWitnesses;
     };
 
     enum class PassThroughMode : SlangPassThrough
@@ -319,7 +328,8 @@ namespace Slang
         int addEntryPoint(
             int                     translationUnitIndex,
             String const&           name,
-            Profile                 profile);
+            Profile                 profile,
+            List<String> const &    genericTypeNames);
 
         UInt addTarget(
             CodeGenTarget   target);

source/slang/decl-defs.h

@@ -126,6 +126,11 @@ END_SYNTAX_CLASS()
 SYNTAX_CLASS(AssocTypeDecl, AggTypeDecl)
 END_SYNTAX_CLASS()
 
+// A '__generic_param' declaration, which defines a generic 
+// entry-point parameter. Is a container of GenericTypeConstraintDecl
+SYNTAX_CLASS(GlobalGenericParamDecl, AggTypeDecl)
+END_SYNTAX_CLASS()
+
 // A scope for local declarations (e.g., as part of a statement)
 SIMPLE_SYNTAX_CLASS(ScopeDecl, ContainerDecl)
 

source/slang/diagnostic-defs.h

@@ -196,7 +196,7 @@ DIAGNOSTIC(33070, Error, expectedFunction, "expression preceding parenthesis of
 
 // 303xx: interfaces and associated types
 DIAGNOSTIC(30300, Error, assocTypeInInterfaceOnly, "'associatedtype' can only be defined in an 'interface'.")
-
+DIAGNOSTIC(30301, Error, globalGenParamInGlobalScopeOnly, "'__generic_param' can only be defined global scope.")
 // TODO: need to assign numbers to all these extra diagnostics...
 
 DIAGNOSTIC(39999, Error, expectedIntegerConstantWrongType, "expected integer constant (found: '$0')")
@@ -244,11 +244,17 @@ DIAGNOSTIC(38001, Error, ambiguousEntryPoint, "more than one function matches en
 DIAGNOSTIC(38002, Note, entryPointCandidate, "see candidate declaration for entry point '$0'")
 DIAGNOSTIC(38003, Error, entryPointSymbolNotAFunction, "entry point '$0' must be declared as a function")
 
+DIAGNOSTIC(38004, Error, entryPointTypeParameterNotFound, "no type found matching entry-point type parameter name '$0'")
+DIAGNOSTIC(38005, Error, entryPointTypeSymbolNotAType, "entry-point type parameter '$0' must be declared as a type")
+
 DIAGNOSTIC(38100, Error, typeDoesntImplementInterfaceRequirement, "type '$0' does not provide required interface member '$1'")
 DIAGNOSTIC(38101, Error, thisExpressionOutsideOfTypeDecl, "'this' expression can only be used in members of an aggregate type")
 DIAGNOSTIC(38102, Error, initializerNotInsideType, "an 'init' declaration is only allowed inside a type or 'extension' declaration")
 DIAGNOSTIC(38102, Error, accessorMustBeInsideSubscriptOrProperty, "an accessor declaration is only allowed inside a subscript or property declaration")
 
+DIAGNOSTIC(38020, Error, mismatchEntryPointTypeArgument, "expecting $0 entry-point type arguments, provided $1.")
+DIAGNOSTIC(38021, Error, typeArgumentDoesNotConformToInterface, "type argument `$1` for generic parameter `$0` does not conform to interface `$1`.")
+
 //
 // 4xxxx - IL code generation.
 //
@@ -264,7 +270,6 @@ DIAGNOSTIC(49999, Error, unknownSystemValueSemantic, "unknown system-value seman
 //
 // 5xxxx - Target code generation.
 //
-
 DIAGNOSTIC(50020, Error, unknownStageType,              "Unknown stage type '$0'.")
 DIAGNOSTIC(50020, Error, invalidTessCoordType,          "TessCoord must have vec2 or vec3 type.")
 DIAGNOSTIC(50020, Error, invalidFragCoordType,          "FragCoord must be a vec4.")

source/slang/emit.cpp

@@ -3481,9 +3481,9 @@ struct EmitVisitor
             break;
 
         case LayoutResourceKind::RegisterSpace:
+        case LayoutResourceKind::GenericResource:
             // ignore
             break;
-
         default:
             {
                 Emit(": register(");
@@ -6771,7 +6771,7 @@ EntryPointLayout* findEntryPointLayout(
 StructTypeLayout* getGlobalStructLayout(
     ProgramLayout*  programLayout)
 {
-    auto globalScopeLayout = programLayout->globalScopeLayout;
+    auto globalScopeLayout = programLayout->globalScopeLayout->typeLayout;
     if( auto gs = globalScopeLayout.As<StructTypeLayout>() )
     {
         return gs.Ptr();
@@ -6816,13 +6816,13 @@ String emitEntryPoint(
     EntryPointRequest*  entryPoint,
     ProgramLayout*      programLayout,
     CodeGenTarget       target,
-    CodeGenTarget       finalTarget)
+    TargetRequest*      targetRequest)
 {
     auto translationUnit = entryPoint->getTranslationUnit();
 
     SharedEmitContext sharedContext;
     sharedContext.target = target;
-    sharedContext.finalTarget = finalTarget;
+    sharedContext.finalTarget = targetRequest->target;
     sharedContext.entryPoint = entryPoint;
 
     if (entryPoint)
@@ -6890,7 +6890,8 @@ String emitEntryPoint(
         auto lowered = specializeIRForEntryPoint(
             entryPoint,
             programLayout,
-            target);
+            target, 
+            targetRequest);
 
         // If the user specified the flag that they want us to dump
         // IR, then do it here, for the target-specific, but

source/slang/emit.h

@@ -26,8 +26,7 @@ namespace Slang
         // The target language to generate code in (e.g., HLSL/GLSL)
         CodeGenTarget       target,
 
-        // The "final" target that we are being asked to compile for
-        // (e.g., SPIR-V, DXBC, ...).
-        CodeGenTarget       finalTarget);
+        // The full target request
+        TargetRequest*      targetRequest);
 }
 #endif