Add type-flow analysis pass for specialized dynamic dispatch

source/slang/slang-diagnostic-defs.h

@@ -2896,6 +2896,11 @@ DIAGNOSTIC(
     noTypeConformancesFoundForInterface,
     "No type conformances are found for interface '$0'. Code generation for current target "
     "requires at least one implementation type present in the linkage.")
+DIAGNOSTIC(
+    50101,
+    Error,
+    dynamicDispatchOnPotentiallyUninitializedExistential,
+    "Cannot dynamically dispatch on potentially uninitialized interface object '$0'.")
 
 DIAGNOSTIC(
     52000,

source/slang/slang-emit-vm.cpp

@@ -1083,6 +1083,11 @@ class ByteCodeEmitter
         }
     }
 
+    bool isUnreachableBlock(IRBlock* block)
+    {
+        return as<IRUnreachable>(block->getTerminator()) != nullptr;
+    }
+
     void emitFunction(IRFunc* func)
     {
         VMByteCodeFunctionBuilder funcBuilder;
@@ -1100,6 +1105,9 @@ class ByteCodeEmitter
 
         for (auto block : func->getBlocks())
         {
+            if (isUnreachableBlock(block))
+                continue;
+
             mapBlockToByteOffset[block] = funcBuilder.code.getCount();
 
             for (auto inst : block->getChildren())

source/slang/slang-emit.cpp

@@ -22,6 +22,7 @@
 #include "slang-emit-vm.h"
 #include "slang-emit-wgsl.h"
 #include "slang-ir-any-value-inference.h"
+#include "slang-ir-any-value-marshalling.h"
 #include "slang-ir-autodiff.h"
 #include "slang-ir-bind-existentials.h"
 #include "slang-ir-byte-address-legalize.h"
@@ -77,9 +78,9 @@
 #include "slang-ir-lower-buffer-element-type.h"
 #include "slang-ir-lower-combined-texture-sampler.h"
 #include "slang-ir-lower-coopvec.h"
+#include "slang-ir-lower-dynamic-dispatch-insts.h"
 #include "slang-ir-lower-dynamic-resource-heap.h"
 #include "slang-ir-lower-enum-type.h"
-#include "slang-ir-lower-generics.h"
 #include "slang-ir-lower-glsl-ssbo-types.h"
 #include "slang-ir-lower-l-value-cast.h"
 #include "slang-ir-lower-optional-type.h"
@@ -114,6 +115,7 @@
 #include "slang-ir-synthesize-active-mask.h"
 #include "slang-ir-transform-params-to-constref.h"
 #include "slang-ir-translate-global-varying-var.h"
+#include "slang-ir-typeflow-specialize.h"
 #include "slang-ir-undo-param-copy.h"
 #include "slang-ir-uniformity.h"
 #include "slang-ir-user-type-hint.h"
@@ -862,6 +864,12 @@ Result linkAndOptimizeIR(
     // Lower all the LValue implict casts (used for out/inout/ref scenarios)
     SLANG_PASS(lowerLValueCast, targetProgram);
 
+    // Lower enum types early since enums and enum casts may appear in
+    // specialization & not resolving them here would block specialization.
+    //
+    if (requiredLoweringPassSet.enumType)
+        SLANG_PASS(lowerEnumType, sink);
+
     IRSimplificationOptions defaultIRSimplificationOptions =
         IRSimplificationOptions::getDefault(targetProgram);
     IRSimplificationOptions fastIRSimplificationOptions =
@@ -1111,21 +1119,14 @@ Result linkAndOptimizeIR(
         SLANG_RETURN_ON_FAIL(SLANG_PASS(performTypeInlining, targetProgram, sink));
     }
 
-    if (requiredLoweringPassSet.reinterpret)
-        SLANG_PASS(lowerReinterpret, targetProgram, sink);
-
     if (sink->getErrorCount() != 0)
         return SLANG_FAIL;
 
     validateIRModuleIfEnabled(codeGenContext, irModule);
 
-    SLANG_PASS(inferAnyValueSizeWhereNecessary, targetProgram);
+    SLANG_PASS(inferAnyValueSizeWhereNecessary, targetProgram, sink);
 
-    // If we have any witness tables that are marked as `KeepAlive`,
-    // but are not used for dynamic dispatch, unpin them so we don't
-    // do unnecessary work to lower them.
     SLANG_PASS(unpinWitnessTables);
-
     if (!fastIRSimplificationOptions.minimalOptimization)
     {
         SLANG_PASS(simplifyIR, targetProgram, fastIRSimplificationOptions, sink);
@@ -1135,6 +1136,26 @@ Result linkAndOptimizeIR(
         SLANG_PASS(eliminateDeadCode, fastIRSimplificationOptions.deadCodeElimOptions);
     }
 
+    // Tagged union type lowering typically generates more reinterpret instructions.
+    if (SLANG_PASS(lowerTaggedUnionTypes, sink))
+        requiredLoweringPassSet.reinterpret = true;
+
+    SLANG_PASS(lowerUntaggedUnionTypes, targetProgram, sink);
+
+    if (requiredLoweringPassSet.reinterpret)
+        SLANG_PASS(lowerReinterpret, targetProgram, sink);
+
+    SLANG_PASS(lowerSequentialIDTagCasts, codeGenContext->getLinkage(), sink);
+    SLANG_PASS(lowerTagInsts, sink);
+    SLANG_PASS(lowerTagTypes);
+
+    SLANG_PASS(eliminateDeadCode, fastIRSimplificationOptions.deadCodeElimOptions);
+
+    SLANG_PASS(lowerExistentials, targetProgram, sink);
+
+    if (sink->getErrorCount() != 0)
+        return SLANG_FAIL;
+
     if (!ArtifactDescUtil::isCpuLikeTarget(artifactDesc) &&
         targetProgram->getOptionSet().shouldRunNonEssentialValidation())
     {
@@ -1143,16 +1164,9 @@ Result linkAndOptimizeIR(
         SLANG_RETURN_ON_FAIL(SLANG_PASS(checkGetStringHashInsts, sink));
     }
 
-    // For targets that supports dynamic dispatch, we need to lower the
-    // generics / interface types to ordinary functions and types using
-    // function pointers.
-    if (requiredLoweringPassSet.generics)
-        SLANG_PASS(lowerGenerics, targetProgram, sink);
-    else
-        SLANG_PASS(cleanupGenerics, targetProgram, sink);
+    SLANG_PASS(lowerTuples, sink);
 
-    if (requiredLoweringPassSet.enumType)
-        SLANG_PASS(lowerEnumType, sink);
+    SLANG_PASS(generateAnyValueMarshallingFunctions);
 
     // Don't need to run any further target-dependent passes if we are generating code
     // for host vm.

source/slang/slang-ir-any-value-inference.cpp

@@ -1,7 +1,6 @@
 #include "slang-ir-any-value-inference.h"
 
 #include "../core/slang-func-ptr.h"
-#include "slang-ir-generics-lowering-context.h"
 #include "slang-ir-insts.h"
 #include "slang-ir-layout.h"
 #include "slang-ir-util.h"
@@ -90,7 +89,10 @@ List<IRInterfaceType*> sortTopologically(
     return sortedInterfaceTypes;
 }
 
-void inferAnyValueSizeWhereNecessary(IRModule* module, TargetProgram* targetProgram)
+void inferAnyValueSizeWhereNecessary(
+    IRModule* module,
+    TargetProgram* targetProgram,
+    DiagnosticSink* sink)
 {
     // Go through the global insts and collect all interface types.
     // For each interface type, infer its any-value-size, by looking up
@@ -130,9 +132,10 @@ void inferAnyValueSizeWhereNecessary(IRModule* module, TargetProgram* targetProg
             if (interfaceType->findDecoration<IRBuiltinDecoration>())
                 continue;
 
-            // If the interface already has an explicit any-value-size, don't infer anything.
+            /* If the interface already has an explicit any-value-size, don't infer anything.
             if (interfaceType->findDecoration<IRAnyValueSizeDecoration>())
                 continue;
+            */
 
             // Skip interfaces that are not implemented by any type.
             if (!implementedInterfaces.contains(interfaceType))
@@ -213,6 +216,12 @@ void inferAnyValueSizeWhereNecessary(IRModule* module, TargetProgram* targetProg
 
     for (auto interfaceType : sortedInterfaceTypes)
     {
+        IRIntegerValue existingMaxSize = (IRIntegerValue)kMaxInt; // Default to max int.
+        if (auto existingAnyValueDecor = interfaceType->findDecoration<IRAnyValueSizeDecoration>())
+        {
+            existingMaxSize = existingAnyValueDecor->getSize();
+        }
+
         IRIntegerValue maxAnyValueSize = -1;
         for (auto implType : mapInterfaceToImplementations[interfaceType])
         {
@@ -223,6 +232,18 @@ void inferAnyValueSizeWhereNecessary(IRModule* module, TargetProgram* targetProg
                 &sizeAndAlignment);
 
             maxAnyValueSize = Math::Max(maxAnyValueSize, sizeAndAlignment.size);
+
+            // Diagnose if the existing any-value-size is smaller than the inferred size.
+            if (existingMaxSize < sizeAndAlignment.size)
+            {
+                sink->diagnose(implType, Diagnostics::typeDoesNotFitAnyValueSize, implType);
+                sink->diagnoseWithoutSourceView(
+                    implType,
+                    Diagnostics::typeAndLimit,
+                    implType,
+                    sizeAndAlignment.size,
+                    existingMaxSize);
+            }
         }
 
         // Should not encounter interface types without any conforming implementations.
@@ -232,7 +253,10 @@ void inferAnyValueSizeWhereNecessary(IRModule* module, TargetProgram* targetProg
         if (maxAnyValueSize >= 0)
         {
             IRBuilder builder(module);
-            builder.addAnyValueSizeDecoration(interfaceType, maxAnyValueSize);
+            if (!interfaceType->findDecoration<IRAnyValueSizeDecoration>())
+            {
+                builder.addAnyValueSizeDecoration(interfaceType, maxAnyValueSize);
+            }
         }
     }
 }

source/slang/slang-ir-any-value-inference.h

@@ -8,5 +8,8 @@
 
 namespace Slang
 {
-void inferAnyValueSizeWhereNecessary(IRModule* module, TargetProgram* targetProgram);
+void inferAnyValueSizeWhereNecessary(
+    IRModule* module,
+    TargetProgram* targetProgram,
+    DiagnosticSink* sink);
 }