Merge branch 'master' into fix-hoisting-issue

Author: saipraveenb25

cmake/CompilerFlags.cmake

@@ -205,6 +205,7 @@ function(set_default_compile_options target)
             $<$<BOOL:${SLANG_ENABLE_FULL_DEBUG_VALIDATION}>:SLANG_ENABLE_FULL_IR_VALIDATION>
             $<$<BOOL:${SLANG_ENABLE_IR_BREAK_ALLOC}>:SLANG_ENABLE_IR_BREAK_ALLOC>
             $<$<BOOL:${SLANG_ENABLE_DX_ON_VK}>:SLANG_CONFIG_DX_ON_VK>
+            $<$<STREQUAL:${SLANG_LIB_TYPE},STATIC>:STB_IMAGE_STATIC>
     )
 
     if(SLANG_ENABLE_ASAN)

docs/building.md

@@ -321,6 +321,21 @@ cmake -B build -G Ninja
 cmake --build build -j
 ```
 
+## Static linking against libslang
+
+If linking against a static `libslang.a` you will need to link against some
+dependencies also if you're not already incorporating them into your project.
+
+You will need to link against:
+
+```
+${SLANG_DIR}/build/Release/lib/libslang.a
+${SLANG_DIR}/build/Release/lib/libcompiler-core.a
+${SLANG_DIR}/build/Release/lib/libcore.a
+${SLANG_DIR}/build/external/miniz/libminiz.a
+${SLANG_DIR}/build/external/lz4/build/cmake/liblz4.a
+```
+
 ## Notes
 
 [^1] below 3.25, CMake lacks the ability to mark directories as being

external/CMakeLists.txt

@@ -89,11 +89,19 @@ endif()
 
 # imgui
 add_library(imgui INTERFACE)
-target_include_directories(imgui INTERFACE "${CMAKE_CURRENT_LIST_DIR}/imgui")
+target_include_directories(
+    imgui
+    ${system}
+    INTERFACE "${CMAKE_CURRENT_LIST_DIR}/imgui"
+)
 
 # stb
 add_library(stb INTERFACE)
-target_include_directories(stb INTERFACE "${CMAKE_CURRENT_LIST_DIR}/stb")
+target_include_directories(
+    stb
+    ${system}
+    INTERFACE "${CMAKE_CURRENT_LIST_DIR}/stb"
+)
 
 # slang-rhi
 if(SLANG_ENABLE_SLANG_RHI)

source/slang/core.meta.slang

@@ -1,4 +1,4 @@
-//public module core;
+public module core;
 
 // Slang `core` library
 
@@ -2367,49 +2367,6 @@ __generic<T> __extension vector<T, 4>
 
 ${{{{
 
-// The above extensions are generic in the *type* of the vector,
-// but explicit in the *size*. We will now declare an extension
-// for each builtin type that is generic in the size.
-//
-for (int tt = 0; tt < kBaseTypeCount; ++tt)
-{
-    if(kBaseTypes[tt].tag == BaseType::Void) continue;
-
-    sb << "__generic<let N : int> __extension vector<"
-        << kBaseTypes[tt].name << ",N>\n{\n";
-
-    for (int ff = 0; ff < kBaseTypeCount; ++ff)
-    {
-        if(kBaseTypes[ff].tag == BaseType::Void) continue;
-
-
-        if( tt != ff )
-        {
-            auto cost = getBaseTypeConversionCost(
-                kBaseTypes[tt],
-                kBaseTypes[ff]);
-            auto op = getBaseTypeConversionOp(
-                kBaseTypes[tt],
-                kBaseTypes[ff]);
-
-			// Implicit conversion from a vector of the same
-			// size, but different element type.
-            sb << "    __implicit_conversion(" << cost << ")\n";
-            sb << "    __intrinsic_op(" << int(op) << ")\n";
-            sb << "    __init(vector<" << kBaseTypes[ff].name << ",N> value);\n";
-
-			// Constructor to make a vector from a scalar of another type.
-            if (cost != kConversionCost_Impossible)
-            {
-                cost += kConversionCost_ScalarToVector;
-                sb << "    __implicit_conversion(" << cost << ")\n";
-                sb << "    [__unsafeForceInlineEarly]\n";
-                sb << "    __init(" << kBaseTypes[ff].name << " value) { this = vector<" << kBaseTypes[tt].name << ",N>( " << kBaseTypes[tt].name << "(value)); }\n";
-            }
-        }
-    }
-    sb << "}\n";
-}
 
 for( int R = 1; R <= 4; ++R )
 for( int C = 1; C <= 4; ++C )
@@ -2464,38 +2421,36 @@ for( int C = 1; C <= 4; ++C )
     sb << "}\n";
 }
 
-for (int tt = 0; tt < kBaseTypeCount; ++tt)
-{
-    if(kBaseTypes[tt].tag == BaseType::Void) continue;
-    auto toType = kBaseTypes[tt].name;
 }}}}
 
-__generic<let R : int, let C : int, let L : int> extension matrix<$(toType),R,C,L>
+//@hidden:
+__intrinsic_op($(kIROp_BuiltinCast))
+internal T __builtin_cast<T, U>(U u);
+
+// If T is implicitly convertible to U, then vector<T,N> is implicitly convertible to vector<U,N>.
+__generic<ToType, let N : int> extension vector<ToType,N>
 {
-${{{{
-    for (int ff = 0; ff < kBaseTypeCount; ++ff)
-    {
-        if(kBaseTypes[ff].tag == BaseType::Void) continue;
-        if( tt == ff ) continue;
+    __implicit_conversion(constraint)
+    __intrinsic_op(BuiltinCast)
+    __init<FromType>(vector<FromType,N> value) where ToType(FromType) implicit;
 
-        auto cost = getBaseTypeConversionCost(
-            kBaseTypes[tt],
-            kBaseTypes[ff]);
-        auto fromType = kBaseTypes[ff].name;
-        auto op = getBaseTypeConversionOp(
-                kBaseTypes[tt],
-                kBaseTypes[ff]);
-}}}}
-    __implicit_conversion($(cost))
-    __intrinsic_op($(op))
-    __init(matrix<$(fromType),R,C,L> value);
-${{{{
+    __implicit_conversion(constraint+)
+    [__unsafeForceInlineEarly]
+    [__readNone]
+    [TreatAsDifferentiable]
+    __init<FromType>(FromType value) where ToType(FromType) implicit
+    {
+        this = __builtin_cast<vector<ToType,N>>(vector<FromType,N>(value));
     }
-}}}}
 }
-${{{{
+
+// If T is implicitly convertible to U, then matrix<T,R,C,L> is implicitly convertible to matrix<U,R,C,L>.
+__generic<ToType, let R : int, let C : int, let L : int> extension matrix<ToType,R,C,L>
+{
+    __implicit_conversion(constraint)
+    __intrinsic_op(BuiltinCast)
+    __init<FromType>(matrix<FromType,R,C,L> value) where ToType(FromType) implicit;
 }
-}}}}
 
 //@ hidden:
 __generic<T, U>

source/slang/diff.meta.slang

@@ -1,4 +1,3 @@
-
 /// `[ForwardDerivative(fwdFn)]` attribute can be used to provide a forward-mode
 /// derivative implementation.
 /// Invoking `fwd_diff(decoratedFn)` will place a call to `fwdFn` instead of synthesizing
@@ -80,7 +79,6 @@ attribute_syntax [ForwardDerivative(function)] : ForwardDerivativeAttribute;
 /// For member functions, or functions nested inside namespaces, `bwdFn` may need to be a fully qualified 
 /// name.
 ///
-///
 __attributeTarget(FunctionDeclBase)
 attribute_syntax [BackwardDerivative(function)] : BackwardDerivativeAttribute;
 
@@ -2150,17 +2148,19 @@ DifferentialPair<T> __d_clamp(DifferentialPair<T> dpx, DifferentialPair<T> dpMin
 {
     return DifferentialPair<T>(
         clamp(dpx.p, dpMin.p, dpMax.p),
-        dpx.p < dpMin.p ? dpMin.d : (dpx.p > dpMax.p ? dpMax.d : dpx.d));
+        (dpx.p >= dpMin.p && dpx.p <= dpMax.p) ? dpx.d : (dpx.p < dpMin.p ? dpMin.d : dpMax.d));
 }
 __generic<T : __BuiltinFloatingPointType>
 [BackwardDifferentiable]
 [PreferRecompute]
 [BackwardDerivativeOf(clamp)]
 void __d_clamp(inout DifferentialPair<T> dpx, inout DifferentialPair<T> dpMin, inout DifferentialPair<T> dpMax, T.Differential dOut)
 {
-    dpx = diffPair(dpx.p, dpx.p > dpMin.p && dpx.p < dpMax.p ? dOut : T.dzero());
-    dpMin = diffPair(dpMin.p, dpx.p <= dpMin.p ? dOut : T.dzero());
-    dpMax = diffPair(dpMax.p, dpx.p >= dpMax.p ? dOut : T.dzero());
+    // Propagate the derivative to x if x is within [min, max] (including the boundaries).
+    dpx = diffPair(dpx.p, (dpx.p >= dpMin.p && dpx.p <= dpMax.p) ? dOut : T.dzero());
+    // If x is strictly below min or above max, the gradient is instead applied to the clamp bounds
+    dpMin = diffPair(dpMin.p, dpx.p < dpMin.p ? dOut : T.dzero());
+    dpMax = diffPair(dpMax.p, dpx.p > dpMax.p ? dOut : T.dzero());
 }
 VECTOR_MATRIX_TERNARY_DIFF_IMPL(clamp)
 

source/slang/hlsl.meta.slang

@@ -23667,6 +23667,8 @@ void coopVecOuterProductAccumulate<T : __BuiltinArithmeticType, let M : int, let
 {
     __target_switch
     {
+    case hlsl:
+        __intrinsic_asm "$0.OuterProductAccumulate($1, $2, $3, $4, $5, $6)";
     case spirv:
         let matrixInterpretationSpirv : int = __getSpvCoopVecComponentType(matrixInterpretation);
         let memoryLayoutSpirv : int = __getSpvCoopVecMatrixLayout(memoryLayout);
@@ -23742,6 +23744,8 @@ void coopVecReduceSumAccumulate<T : __BuiltinArithmeticType, let N : int>(
 {
     __target_switch
     {
+    case hlsl:
+        __intrinsic_asm "$0.ReduceSumAccumulate($1, $2)";
     case spirv:
         let bufferPtr = buffer.GetBufferPointer();
         spirv_asm

source/slang/slang-ast-builder.cpp

@@ -948,6 +948,14 @@ SubtypeWitness* ASTBuilder::getConjunctionSubtypeWitness(
     return witness;
 }
 
+TypeCoercionWitness* ASTBuilder::getTypeCoercionWitness(
+    Type* subType,
+    Type* superType,
+    DeclRef<Decl> declRef)
+{
+    return getOrCreate<TypeCoercionWitness>(subType, superType, declRef.declRefBase);
+}
+
 DeclRef<Decl> _getMemberDeclRef(ASTBuilder* builder, DeclRef<Decl> parent, Decl* decl)
 {
     return builder->getMemberDeclRef(parent, decl);

source/slang/slang-ast-builder.h

@@ -636,6 +636,11 @@ class ASTBuilder : public RefObject
         SubtypeWitness* subIsLWitness,
         SubtypeWitness* subIsRWitness);
 
+    TypeCoercionWitness* getTypeCoercionWitness(
+        Type* fromType,
+        Type* toType,
+        DeclRef<Decl> declRef);
+
     /// Helpers to get type info from the SharedASTBuilder
     const ReflectClassInfo* findClassInfo(const UnownedStringSlice& slice)
     {

source/slang/slang-ast-decl.h

@@ -612,6 +612,15 @@ class GenericTypeConstraintDecl : public TypeConstraintDecl
     const TypeExp& _getSupOverride() const { return sup; }
 };
 
+class TypeCoercionConstraintDecl : public Decl
+{
+    SLANG_AST_CLASS(TypeCoercionConstraintDecl)
+
+    SourceLoc whereTokenLoc = SourceLoc();
+    TypeExp fromType;
+    TypeExp toType;
+};
+
 class GenericValueParamDecl : public VarDeclBase
 {
     SLANG_AST_CLASS(GenericValueParamDecl)

source/slang/slang-ast-modifier.h

@@ -1279,10 +1279,10 @@ class ImplicitConversionModifier : public Modifier
     SLANG_AST_CLASS(ImplicitConversionModifier)
 
     // The conversion cost, used to rank conversions
-    ConversionCost cost;
+    ConversionCost cost = kConversionCost_None;
 
     // A builtin identifier for identifying conversions that need special treatment.
-    BuiltinConversionKind builtinConversionKind;
+    BuiltinConversionKind builtinConversionKind = kBuiltinConversion_Unknown;
 };
 
 class FormatAttribute : public Attribute

source/slang/slang-ast-support-types.h

@@ -178,6 +178,11 @@ enum : ConversionCost
     // Additional cost when casting an LValue.
     kConversionCost_LValueCast = 800,
 
+    // The cost of this conversion is defined by the type coercion constraint.
+    kConversionCost_TypeCoercionConstraint = 1000,
+    kConversionCost_TypeCoercionConstraintPlusScalarToVector =
+        kConversionCost_TypeCoercionConstraint + kConversionCost_ScalarToVector,
+
     // Conversion is impossible
     kConversionCost_Impossible = 0xFFFFFFFF,
 };

source/slang/slang-ast-val.cpp

@@ -845,6 +845,58 @@ void ExtractFromConjunctionSubtypeWitness::_toTextOverride(StringBuilder& out)
     out << ")";
 }
 
+void TypeCoercionWitness::_toTextOverride(StringBuilder& out)
+{
+    out << "TypeCoercionWitness(";
+    if (getFromType())
+        out << getFromType();
+    if (getToType())
+        out << getToType();
+    out << ")";
+}
+
+Val* TypeCoercionWitness::_substituteImplOverride(
+    ASTBuilder* astBuilder,
+    SubstitutionSet subst,
+    int* ioDiff)
+{
+    int diff = 0;
+
+    auto substDeclRef = getDeclRef().substituteImpl(astBuilder, subst, &diff);
+    auto substFrom = as<Type>(getFromType()->substituteImpl(astBuilder, subst, &diff));
+    auto substTo = as<Type>(getToType()->substituteImpl(astBuilder, subst, &diff));
+
+    if (!diff)
+        return this;
+
+    (*ioDiff)++;
+
+    TypeCoercionWitness* substValue =
+        astBuilder->getTypeCoercionWitness(substFrom, substTo, substDeclRef);
+    return substValue;
+}
+
+Val* TypeCoercionWitness::_resolveImplOverride()
+{
+    Val* resolvedDeclRef = nullptr;
+    if (getDeclRef())
+        resolvedDeclRef = getDeclRef().declRefBase->resolve();
+    if (auto resolvedVal = as<Witness>(resolvedDeclRef))
+        return resolvedVal;
+
+    auto newFrom = as<Type>(getFromType()->resolve());
+    auto newTo = as<Type>(getToType()->resolve());
+
+    auto newDeclRef = as<DeclRefBase>(resolvedDeclRef);
+    if (!newDeclRef)
+        newDeclRef = getDeclRef().declRefBase;
+    if (newFrom != getFromType() || newTo != getToType() || newDeclRef != getDeclRef())
+    {
+        return getCurrentASTBuilder()->getTypeCoercionWitness(newFrom, newTo, newDeclRef);
+    }
+    return this;
+}
+
 // UNormModifierVal
 
 void UNormModifierVal::_toTextOverride(StringBuilder& out)

source/slang/slang-ast-val.h

@@ -621,6 +621,20 @@ class TypeEqualityWitness : public SubtypeWitness
     Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
 };
 
+class TypeCoercionWitness : public Witness
+{
+    SLANG_AST_CLASS(TypeCoercionWitness)
+
+    Type* getFromType() { return as<Type>(getOperand(0)); }
+    Type* getToType() { return as<Type>(getOperand(1)); }
+
+    DeclRef<Decl> getDeclRef() { return as<DeclRefBase>(getOperand(2)); }
+
+    void _toTextOverride(StringBuilder& out);
+    Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
+    Val* _resolveImplOverride();
+};
+
 // A witness that one type is a subtype of another
 // because some in-scope declaration says so
 class DeclaredSubtypeWitness : public SubtypeWitness