Lower-to-ir no longer produce `Construct` inst. (#2553)

Co-authored-by: Yong He <yhe@nvidia.com>

1 files changed, 70 insertions, 12 deletions

diff --git a/source/slang/core.meta.slang b/source/slang/core.meta.slang
index 73a004720..17af354ca 100644
--- a/source/slang/core.meta.slang
+++ b/source/slang/core.meta.slang
@@ -83,6 +83,7 @@ interface __BuiltinType {}
 /// A type that can be used for arithmetic operations
 [sealed]
 [builtin]
+[TreatAsDifferentiable]
 interface __BuiltinArithmeticType : __BuiltinType
 {
         /// Initialize from a 32-bit signed integer value.
@@ -140,6 +141,7 @@ interface __BuiltinRealType : __BuiltinSignedArithmeticType {}
 /// A type that uses a floating-point representation
 [sealed]
 [builtin]
+[TreatAsDifferentiable]
 interface __BuiltinFloatingPointType : __BuiltinRealType, IDifferentiable
 {
         /// Initialize from a 32-bit floating-point value.
@@ -201,7 +203,9 @@ extension __EnumType
     // interface, but right now the scoping for looking
     // up that type isn't working right.
     //
+    __intrinsic_op($(kIROp_IntCast))
     __init(int value);
+    __intrinsic_op($(kIROp_IntCast))
     __init(uint value);
 }
 
@@ -302,8 +306,13 @@ ${{{{
         ConversionCost conversionCost = getBaseTypeConversionCost(
             kBaseTypes[tt],
             kBaseTypes[ss]);
+
+        IROp intrinsicOpCode = getBaseTypeConversionOp(
+            kBaseTypes[tt],
+            kBaseTypes[ss]);
 }}}}
 
+    __intrinsic_op($(intrinsicOpCode))
     __implicit_conversion($(conversionCost))
     __init($(kBaseTypes[ss].name) value);
 
@@ -325,6 +334,7 @@ ${{{{
     case BaseType::UInt:
 }}}}
         __generic<T:__EnumType>
+        __intrinsic_op($(kIROp_IntCast))
         __init(T value);
 ${{{{
         break;
@@ -380,6 +390,7 @@ ${{{{
 }}}}
         __generic<T>
         [__readNone]
+        __intrinsic_op($(kIROp_CastToVoid))
         __init(T value)
         {}
 ${{{{
@@ -416,10 +427,10 @@ struct Ptr
     __intrinsic_op($(kIROp_BitCast))
     __init(Ptr<U> ptr);
 
-    __intrinsic_op($(kIROp_BitCast))
+    __intrinsic_op($(kIROp_CastIntToPtr))
     __init(uint64_t val);
 
-    __intrinsic_op($(kIROp_BitCast))
+    __intrinsic_op($(kIROp_CastIntToPtr))
     __init(int64_t val);
 
     __subscript(int index) -> T
@@ -491,7 +502,7 @@ extension bool
 extension uint64_t
 {
     __generic<T>
-    __intrinsic_op($(kIROp_Construct))
+    __intrinsic_op($(kIROp_CastPtrToInt))
     __init(Ptr<T> ptr);
 
     static const uint64_t maxValue = 0xFFFFFFFFFFFFFFFFULL;
@@ -501,7 +512,7 @@ extension uint64_t
 extension int64_t
 {
     __generic<T>
-    __intrinsic_op($(kIROp_Construct))
+    __intrinsic_op($(kIROp_CastPtrToInt))
     __init(Ptr<T> ptr);
 
     static const int64_t maxValue =  0x7FFFFFFFFFFFFFFFLL;
@@ -511,7 +522,7 @@ extension int64_t
 extension intptr_t
 {
     __generic<T>
-    __intrinsic_op($(kIROp_Construct))
+    __intrinsic_op($(kIROp_CastPtrToInt))
     __init(Ptr<T> ptr);
     static const intptr_t maxValue = $(SLANG_PROCESSOR_X86_64?"0x7FFFFFFFFFFFFFFFz":"0x7FFFFFFFz");
     static const intptr_t minValue = $(SLANG_PROCESSOR_X86_64?"0x8000000000000000z":"0x80000000z");
@@ -521,7 +532,7 @@ extension intptr_t
 extension uintptr_t
 {
     __generic<T>
-    __intrinsic_op($(kIROp_Construct))
+    __intrinsic_op($(kIROp_CastPtrToInt))
     __init(Ptr<T> ptr);
     static const uintptr_t maxValue = $(SLANG_PROCESSOR_X86_64?"0xFFFFFFFFFFFFFFFFz":"0xFFFFFFFFz");
     static const uintptr_t minValue = 0z;
@@ -620,16 +631,22 @@ __intrinsic_type($(kIROp_StringType))
 struct String
 {
     __target_intrinsic(cpp)
+    __intrinsic_op($(kIROp_makeString))
     __init(int val);
     __target_intrinsic(cpp)
+    __intrinsic_op($(kIROp_makeString))
     __init(uint val);
     __target_intrinsic(cpp)
+    __intrinsic_op($(kIROp_makeString))
     __init(int64_t val);
     __target_intrinsic(cpp)
+    __intrinsic_op($(kIROp_makeString))
     __init(uint64_t val);
     __target_intrinsic(cpp)
+    __intrinsic_op($(kIROp_makeString))
     __init(float val);
     __target_intrinsic(cpp)
+    __intrinsic_op($(kIROp_makeString))
     __init(double val);
 
     __target_intrinsic(cpp)
@@ -750,6 +767,7 @@ struct vector
 
         /// Initialize a vector from a value of the same type
     // TODO: we should revise semantic checking so this kind of "identity" conversion is not required
+    __intrinsic_op(0)
     __init(vector<T,N> value);
 }
 
@@ -871,22 +889,49 @@ struct Primitives
 
 __generic<T> __extension vector<T, 2>
 {
+    __intrinsic_op($(kIROp_makeVector))
     __init(T x, T y);
 }
 __generic<T> __extension vector<T, 3>
 {
+    __intrinsic_op($(kIROp_makeVector))
     __init(T x, T y, T z);
+
+    [__unsafeForceInlineEarly]
+    __intrinsic_op($(kIROp_makeVector))
     __init(vector<T,2> xy, T z);
+
+    [__unsafeForceInlineEarly]
+    __intrinsic_op($(kIROp_makeVector))
     __init(T x, vector<T,2> yz);
 }
 __generic<T> __extension vector<T, 4>
 {
+    __intrinsic_op($(kIROp_makeVector))
     __init(T x, T y, T z, T w);
+
+    [__unsafeForceInlineEarly]
+    __intrinsic_op($(kIROp_makeVector))
     __init(vector<T,2> xy, T z, T w);
+
+    [__unsafeForceInlineEarly]
+    __intrinsic_op($(kIROp_makeVector))
     __init(T x, vector<T,2> yz, T w);
+
+    [__unsafeForceInlineEarly]
+    __intrinsic_op($(kIROp_makeVector))
     __init(T x, T y, vector<T,2> zw);
+
+    [__unsafeForceInlineEarly]
+    __intrinsic_op($(kIROp_makeVector))
     __init(vector<T,2> xy, vector<T,2> zw);
+
+    [__unsafeForceInlineEarly]
+    __intrinsic_op($(kIROp_makeVector))
     __init(vector<T,3> xyz, T w);
+
+    [__unsafeForceInlineEarly]
+    __intrinsic_op($(kIROp_makeVector))
     __init(T x, vector<T,3> yzw);
 }
 
@@ -915,16 +960,24 @@ for (int tt = 0; tt < kBaseTypeCount; ++tt)
             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.
-            cost += kConversionCost_ScalarToVector;
-            sb << "    __implicit_conversion(" << cost << ")\n";
-            sb << "    __init(" << kBaseTypes[ff].name << " value);\n";
+            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";
@@ -936,7 +989,7 @@ for( int C = 2; C <= 4; ++C )
     sb << "__generic<T> __extension matrix<T, " << R << "," << C << ">\n{\n";
 
     // initialize from R*C scalars
-    sb << "__init(";
+    sb << "__intrinsic_op(" << int(kIROp_MakeMatrix) << ") __init(";
     for( int ii = 0; ii < R; ++ii )
     for( int jj = 0; jj < C; ++jj )
     {
@@ -946,7 +999,7 @@ for( int C = 2; C <= 4; ++C )
     sb << ");\n";
 
     // Initialize from R C-vectors
-    sb << "__init(";
+    sb << "__intrinsic_op(" << int(kIROp_MakeMatrix) << ") __init(";
     for (int ii = 0; ii < R; ++ii)
     {
         if(ii != 0) sb << ", ";
@@ -959,7 +1012,7 @@ for( int C = 2; C <= 4; ++C )
     for( int cc = C; cc <= 4; ++cc )
     {
         if(rr == R && cc == C) continue;
-        sb << "__init(matrix<T," << rr << "," << cc << "> value);\n";
+        sb << "__intrinsic_op(" << int(kIROp_MatrixTruncate) << ") __init(matrix<T," << rr << "," << cc << "> value);\n";
     }
     sb << "}\n";
 }
@@ -982,8 +1035,12 @@ ${{{{
             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> value);
 ${{{{
     }
@@ -1026,6 +1083,7 @@ extension matrix<T, R, C> : IDifferentiable
 {
     typedef matrix<T, R, C> Differential;
 
+    __intrinsic_op($(kIROp_MakeMatrixFromScalar))
     __init(T val);
 
     [__unsafeForceInlineEarly]