Enable lower-generics pass universally. (shader-slang#1518)

* Enable lower-generics pass universally.

* Exclude builtin interfaces and functions from lower-generics pass.

* Update stdlib.

* Fixup.

* Fixes handling of nested intrinsic generic functions.

* Fixes.

* Fixes.

Author: csyonghe

source/slang/core.meta.slang

@@ -19,10 +19,12 @@ syntax globallycoherent : GloballyCoherentModifier;
 
 // A type that can be used as an operand for builtins
 [sealed]
+[builtin]
 interface __BuiltinType {}
 
 // A type that can be used for arithmetic operations
 [sealed]
+[builtin]
 interface __BuiltinArithmeticType : __BuiltinType
 {
         /// Initialize from a 32-bit signed integer value.
@@ -31,23 +33,28 @@ interface __BuiltinArithmeticType : __BuiltinType
 
     /// A type that can be used for logical/bitwsie operations
 [sealed]
+[builtin]
 interface __BuiltinLogicalType : __BuiltinType {}
 
 // A type that logically has a sign (positive/negative/zero)
 [sealed]
+[builtin]
 interface __BuiltinSignedArithmeticType : __BuiltinArithmeticType {}
 
 // A type that can represent integers
 [sealed]
+[builtin]
 interface __BuiltinIntegerType : __BuiltinArithmeticType
 {}
 
 // A type that can represent non-integers
 [sealed]
+[builtin]
 interface __BuiltinRealType : __BuiltinSignedArithmeticType {}
 
 // A type that uses a floating-point representation
 [sealed]
+[builtin]
 interface __BuiltinFloatingPointType : __BuiltinRealType
 {
         /// Initialize from a 32-bit floating-point value.
@@ -58,6 +65,7 @@ interface __BuiltinFloatingPointType : __BuiltinRealType
 }
 
 // A type resulting from an `enum` declaration.
+[builtin]
 __magic_type(EnumTypeType)
 interface __EnumType
 {
@@ -112,6 +120,7 @@ extension __EnumType
 
 // A type resulting from an `enum` declaration
 // with the `[flags]` attribute.
+[builtin]
 interface __FlagsEnumType : __EnumType
 {
 };
@@ -2042,3 +2051,6 @@ attribute_syntax [open] : OpenAttribute;
 
 __attributeTarget(InterfaceDecl)
 attribute_syntax [anyValueSize(size:int)] : AnyValueSizeAttribute;
+
+__attributeTarget(DeclBase)
+attribute_syntax [builtin] : BuiltinAttribute;

source/slang/hlsl.meta.slang

@@ -4302,6 +4302,7 @@ void DispatchMesh<P>(uint threadGroupCountX, uint threadGroupCountY, uint thread
 // But slang enums are always 'enum class like', so I use an empty struct type here
 
 [sealed]
+[builtin]
 interface __BuiltinSamplerFeedbackType {};
 
 [sealed]

source/slang/slang-ast-modifier.h

@@ -878,6 +878,12 @@ class OpenAttribute : public InheritanceControlAttribute { SLANG_CLASS(OpenAttri
     /// An attribute that marks a type declaration as disallowing the type to be inherited from in other modules.
 class SealedAttribute : public InheritanceControlAttribute { SLANG_CLASS(SealedAttribute) };
 
+    /// An attribute that marks a decl as a compiler built-in object.
+class BuiltinAttribute : public Attribute
+{
+    SLANG_CLASS(BuiltinAttribute)
+};
+
     /// An attribute that defines the size of `AnyValue` type to represent a polymoprhic value that conforms to
     /// the decorated interface type.
 class AnyValueSizeAttribute : public Attribute

source/slang/slang-compiler.h

@@ -1760,8 +1760,8 @@ namespace Slang
         bool shouldEmitSPIRVDirectly = false;
 
 
-        // If true will allow generating dynamic dispatch code for generics.
-        bool allowDynamicCode = false;
+        // If true will disable generics/existential value specialization pass.
+        bool disableSpecialization = false;
 
         String m_dumpIntermediatePrefix;
 

source/slang/slang-emit-c-like.cpp

@@ -299,7 +299,6 @@ void CLikeSourceEmitter::_emitType(IRType* type, EDeclarator* declarator)
 void CLikeSourceEmitter::emitWitnessTable(IRWitnessTable* witnessTable)
 {
     SLANG_UNUSED(witnessTable);
-    SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "Unimplemented emit: IROpWitnessTable.");
 }
 
 void CLikeSourceEmitter::emitInterface(IRInterfaceType* interfaceType)
@@ -3824,13 +3823,6 @@ void CLikeSourceEmitter::ensureGlobalInst(ComputeEmitActionsContext* ctx, IRInst
     // Skip certain instructions that don't affect output.
     switch(inst->op)
     {
-    case kIROp_WitnessTable:
-        // Only skip witness tables when we are generating
-        // static code.
-        if (!m_compileRequest->allowDynamicCode)
-            return;
-        break;
-
     case kIROp_InterfaceRequirementEntry:
     case kIROp_Generic:
         return;

source/slang/slang-emit-cpp.cpp

@@ -1607,6 +1607,11 @@ void CPPSourceEmitter::emitParamTypeImpl(IRType* type, String const& name)
 void CPPSourceEmitter::emitWitnessTable(IRWitnessTable* witnessTable)
 {
     auto interfaceType = cast<IRInterfaceType>(witnessTable->getOperand(0));
+
+    // Ignore witness tables for builtin interface types.
+    if (isBuiltin(interfaceType))
+        return;
+
     auto witnessTableItems = witnessTable->getChildren();
     _maybeEmitWitnessTableTypeDefinition(interfaceType);
 

source/slang/slang-emit.cpp

@@ -302,20 +302,20 @@ Result linkAndOptimizeIR(
     // perform specialization of functions based on parameter
     // values that need to be compile-time constants.
     //
-    if (!compileRequest->allowDynamicCode)
+    if (!compileRequest->disableSpecialization)
         specializeModule(irModule);
 
+    eliminateDeadCode(irModule);
+
     switch (target)
     {
     case CodeGenTarget::CPPSource:
         // For targets that supports dynamic dispatch, we need to lower the
         // generics / interface types to ordinary functions and types using
         // function pointers.
-        if (compileRequest->allowDynamicCode)
-        {
-            lowerGenerics(irModule, sink);
-            dumpIRIfEnabled(compileRequest, irModule, "LOWER-GENERICS");
-        }
+        dumpIRIfEnabled(compileRequest, irModule, "BEFORE-LOWER-GENERICS");
+        lowerGenerics(irModule, sink);
+        dumpIRIfEnabled(compileRequest, irModule, "LOWER-GENERICS");
         break;
     default:
         break;
@@ -658,12 +658,16 @@ Result linkAndOptimizeIR(
         break;
     }
 
-    if (!compileRequest->allowDynamicCode)
+    switch (target)
     {
+    case CodeGenTarget::CPPSource:
+        break;
+    default:
         // For all targets that don't support true dynamic dispatch through
         // witness tables, we need to eliminate witness tables from the IR so
         // that they don't keep symbols live that we don't actually need.
         stripWitnessTables(irModule);
+        break;
     }
 
 #if 0

source/slang/slang-ir-generics-lowering-context.cpp

@@ -142,13 +142,17 @@ namespace Slang
         {
             if (auto anyValueSizeDecor = paramType->findDecoration<IRTypeConstraintDecoration>())
             {
+                if (isBuiltin(anyValueSizeDecor->getConstraintType()))
+                    return (IRType*)paramType;
                 anyValueSize = getInterfaceAnyValueSize(anyValueSizeDecor->getConstraintType(), paramType->sourceLoc);
                 return builder->getAnyValueType(anyValueSize);
             }
             sink->diagnose(paramType, Diagnostics::unconstrainedGenericParameterNotAllowedInDynamicFunction, paramType);
             return builder->getAnyValueType(kInvalidAnyValueSize);
         }
         case kIROp_ThisType:
+            if (isBuiltin(cast<IRThisType>(paramType)->getConstraintType()))
+                return (IRType*)paramType;
             anyValueSize = getInterfaceAnyValueSize(
                 cast<IRThisType>(paramType)->getConstraintType(),
                 paramType->sourceLoc);
@@ -159,6 +163,8 @@ namespace Slang
         }
         case kIROp_InterfaceType:
         {
+            if (isBuiltin(paramType))
+                return (IRType*)paramType;
             // An existential type translates into a tuple of (AnyValue, WitnessTable, RTTI*)
             anyValueSize = getInterfaceAnyValueSize(paramType, paramType->sourceLoc);
             auto anyValueType = builder->getAnyValueType(anyValueSize);
@@ -172,6 +178,8 @@ namespace Slang
             auto lookupInterface = static_cast<IRLookupWitnessMethod*>(paramType);
             auto interfaceType = cast<IRInterfaceType>(cast<IRWitnessTableType>(
                 lookupInterface->getWitnessTable()->getDataType())->getConformanceType());
+            if (isBuiltin(interfaceType))
+                return (IRType*)paramType;
             // Make sure we are looking up inside the original interface type (prior to lowering).
             // Only in the original interface type will an associated type entry have an IRAssociatedType value.
             // We need to extract AnyValueSize from this IRAssociatedType.

source/slang/slang-ir-inst-defs.h

@@ -561,6 +561,8 @@ INST(HighLevelDeclDecoration,               highLevelDecl,          1, 0)
     INST(TypeConstraintDecoration, TypeConstraintDecoration, 1, 0)
     INST_RANGE(LinkageDecoration, ImportDecoration, ExportDecoration)
 
+    INST(BuiltinDecoration, BuiltinDecoration, 0, 0)
+
     INST(SemanticDecoration, semantic, 2, 0)
 
     INST_RANGE(Decoration, HighLevelDeclDecoration, SemanticDecoration)

source/slang/slang-ir-insts.h

@@ -423,6 +423,15 @@ struct IRNaturalOffsetDecoration : IRDecoration
     IRIntegerValue getOffset() { return getOffsetOperand()->getValue(); }
 };
 
+struct IRBuiltinDecoration : IRDecoration
+{
+    enum
+    {
+        kOp = kIROp_BuiltinDecoration
+    };
+    IR_LEAF_ISA(BuiltinDecoration)
+};
+
 // An instruction that specializes another IR value
 // (representing a generic) to a particular set of generic arguments 
 // (instructions representing types, witness tables, etc.)
@@ -2457,6 +2466,11 @@ struct IRBuilder
     {
         addDecoration(inst, kIROp_TypeConstraintDecoration, constraintType);
     }
+
+    void addBuiltinDecoration(IRInst* inst)
+    {
+        addDecoration(inst, kIROp_BuiltinDecoration);
+    }
 };
 
 void addHoistableInst(

source/slang/slang-ir-lower-generic-call.cpp

@@ -170,6 +170,14 @@ namespace Slang
             }
         }
 
+        IRInst* findInnerMostSpecializingBase(IRSpecialize* inst)
+        {
+            auto result = inst->getBase();
+            while (auto specialize = as<IRSpecialize>(result))
+                result = specialize->getBase();
+            return result;
+        }
+
         void lowerCallToSpecializedFunc(IRCall* callInst, IRSpecialize* specializeInst)
         {
             // If we see a call(specialize(gFunc, Targs), args),
@@ -180,9 +188,23 @@ namespace Slang
             // them here.
             if (loweredFunc->op == kIROp_Generic)
             {
-                // This is an intrinsic function, don't transform.
                 return;
             }
+            else if (loweredFunc->op == kIROp_Specialize)
+            {
+                // All nested generic functions are supposed to be flattend before this pass.
+                // If they are not, they represent an intrinsic function that should not be
+                // modified in this pass.
+                auto innerMostFunc = findInnerMostSpecializingBase(static_cast<IRSpecialize*>(loweredFunc));
+                if (innerMostFunc && innerMostFunc->op == kIROp_Generic)
+                {
+                    innerMostFunc =
+                        findInnerMostGenericReturnVal(static_cast<IRGeneric*>(innerMostFunc));
+                }
+                if (innerMostFunc->findDecoration<IRTargetIntrinsicDecoration>())
+                    return;
+                SLANG_UNEXPECTED("Nested generics specialization.");
+            }
             IRFuncType* funcType = cast<IRFuncType>(loweredFunc->getDataType());
             translateCallInst(callInst, funcType, loweredFunc, specializeInst);
         }
@@ -193,6 +215,9 @@ namespace Slang
             // all occurences of associatedtypes.
             auto funcType = cast<IRFuncType>(lookupInst->getDataType());
             auto loweredFunc = lookupInst;
+            if (isBuiltin(cast<IRWitnessTableType>(
+                lookupInst->getWitnessTable()->getDataType())->getConformanceType()))
+                return;
             translateCallInst(callInst, funcType, loweredFunc, nullptr);
         }
 

source/slang/slang-ir-lower-generic-function.cpp

@@ -21,9 +21,21 @@ namespace Slang
             IRInst* result = nullptr;
             if (sharedContext->loweredGenericFunctions.TryGetValue(genericValue, result))
                 return result;
+            // Do not lower intrinsic functions.
+            if (genericValue->findDecoration<IRTargetIntrinsicDecoration>())
+                return genericValue;
             auto genericParent = as<IRGeneric>(genericValue);
             SLANG_ASSERT(genericParent);
             auto func = as<IRFunc>(findGenericReturnVal(genericParent));
+            if (!func)
+            {
+                // Nested generic functions are supposed to be flattened before entering
+                // this pass. The reason we are still seeing them must be that they are
+                // intrinsic functions. In this case we ignore the function.
+                SLANG_ASSERT(findInnerMostGenericReturnVal(genericParent)
+                                 ->findDecoration<IRTargetIntrinsicDecoration>() != nullptr);
+                return genericValue;
+            }
             SLANG_ASSERT(func);
             if (!func->isDefinition())
             {
@@ -133,7 +145,9 @@ namespace Slang
                 return loweredType;
             if (sharedContext->mapLoweredInterfaceToOriginal.ContainsKey(interfaceType))
                 return interfaceType;
-
+            // Do not lower intrinsic interfaces.
+            if (isBuiltin(interfaceType))
+                return interfaceType;
             List<IRInterfaceRequirementEntry*> newEntries;
 
             IRBuilder builder;
@@ -189,6 +203,8 @@ namespace Slang
             auto interfaceType = maybeLowerInterfaceType(cast<IRInterfaceType>(witnessTable->getConformanceType()));
             if (interfaceType != witnessTable->getConformanceType())
                 witnessTable->setConformanceType(interfaceType);
+            if (isBuiltin(interfaceType))
+                return;
             for (auto child : witnessTable->getChildren())
             {
                 auto entry = as<IRWitnessTableEntry>(child);

source/slang/slang-ir-witness-table-wrapper.cpp

@@ -174,6 +174,8 @@ namespace Slang
         void lowerWitnessTable(IRWitnessTable* witnessTable)
         {
             auto interfaceType = cast<IRInterfaceType>(witnessTable->getConformanceType());
+            if (isBuiltin(interfaceType))
+                return;
             for (auto child : witnessTable->getChildren())
             {
                 auto entry = as<IRWitnessTableEntry>(child);

source/slang/slang-ir.cpp

@@ -5263,6 +5263,7 @@ namespace Slang
         case kIROp_GlobalGenericParam:
         case kIROp_WitnessTable:
         case kIROp_WitnessTableEntry:
+        case kIROp_InterfaceRequirementEntry:
         case kIROp_Block:
             return false;
 
@@ -5384,6 +5385,14 @@ namespace Slang
         auto val = returnInst->getVal();
         return val;
     }
+    
+    IRInst* findInnerMostGenericReturnVal(IRGeneric* generic)
+    {
+        IRInst* inst = generic;
+        while (auto genericInst = as<IRGeneric>(inst))
+            inst = findGenericReturnVal(genericInst);
+        return inst;
+    }
 
     IRGeneric* findSpecializedGeneric(IRSpecialize* specialize)
     {
@@ -5488,9 +5497,15 @@ namespace Slang
     {
         return ptrType && ptrType->op == kIROp_PtrType && ptrType->getOperand(0) == elementType;
     }
+
     bool isPointerOfType(IRInst* ptrType, IROp opCode)
     {
         return ptrType && ptrType->op == kIROp_PtrType && ptrType->getOperand(0) &&
             ptrType->getOperand(0)->op == opCode;
     }
-}
+    bool isBuiltin(IRInst* inst)
+    {
+        return inst->findDecoration<IRBuiltinDecoration>() != nullptr;
+    }
+} // namespace Slang
+