Small fixes and cleanups on CUDA/CPP codegen. (#2746)

* Small fixes and cleanups on CUDA/CPP codegen.

* Disable `legalizeEmptyTypes` for now.

---------

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

8 files changed, 78 insertions, 1 deletions

diff --git a/source/slang/diff.meta.slang b/source/slang/diff.meta.slang
index d5b70bbb3..d5dc7842a 100644
--- a/source/slang/diff.meta.slang
+++ b/source/slang/diff.meta.slang
@@ -31,6 +31,7 @@ __intrinsic_type($(kIROp_TensorViewType))
 struct TensorView
 {
     __target_intrinsic(cuda, "$0.data_ptr<$G0>()")
+    [__readNone]
     Ptr<T> data_ptr();
 
     __implicit_conversion($(kConversionCost_ImplicitDereference))
@@ -38,14 +39,19 @@ struct TensorView
     __init(TorchTensor<T> t);
 
     __target_intrinsic(cuda, "$0.load<$G0>($1)")
+    [__readNone]
     T load(uint x);
     __target_intrinsic(cuda, "$0.load<$G0>($1, $2)")
+    [__readNone]
     T load(uint x, uint y);
     __target_intrinsic(cuda, "$0.load<$G0>($1, $2, $3)")
+    [__readNone]
     T load(uint x, uint y, uint z);
     __target_intrinsic(cuda, "$0.load<$G0>($1, $2, $3, $4)")
+    [__readNone]
     T load(uint x, uint y, uint z, uint w);
     __target_intrinsic(cuda, "$0.load<$G0>($1, $2, $3, $4, $5)")
+    [__readNone]
     T load(uint i0, uint i1, uint i2, uint i3, uint i4);
 
     __target_intrinsic(cuda, "$0.store<$G0>($1, $2)")
@@ -60,12 +66,15 @@ struct TensorView
     void store(uint i0, uint i1, uint i2, uint i3, uint i4, T val);
 
     __target_intrinsic(cuda, "$0.dimensionCount")
+    [__readNone]
     uint dims();
 
     __target_intrinsic(cuda, "$0.sizes[$1]")
+    [__readNone]
     uint size(uint i);
 
     __target_intrinsic(cuda, "$0.strides[$1]")
+    [__readNone]
     uint stride(uint i);
 }
 
@@ -78,18 +87,22 @@ struct TorchTensor
 
     __target_intrinsic(cuda, "$0.dims()")
     __target_intrinsic(cpp, "$0.dims()")
+    [__readNone]
     uint dims();
 
     __target_intrinsic(cuda, "$0.size($1)")
     __target_intrinsic(cpp, "$0.size($1)")
+    [__readNone]
     uint size(uint i);
 
     __target_intrinsic(cuda, "$0.stride($1)")
     __target_intrinsic(cpp, "$0.stride($1)")
+    [__readNone]
     uint stride(uint i);
 
     __target_intrinsic(cuda, "$0.data_ptr<$G0>()")
     __target_intrinsic(cpp, "$0.data_ptr<$G0>()")
+    [__readNone]
     Ptr<T> data_ptr();
 
     __intrinsic_op($(kIROp_AllocateTorchTensor))
diff --git a/source/slang/hlsl.meta.slang b/source/slang/hlsl.meta.slang
index 4c4aaa4f0..7774c0d01 100644
--- a/source/slang/hlsl.meta.slang
+++ b/source/slang/hlsl.meta.slang
@@ -6837,10 +6837,13 @@ void debugBreak();
 
 
 __target_intrinsic(cuda, "(threadIdx)")
+[__readNone]
 uint3 cudaThreadIdx();
 
 __target_intrinsic(cuda, "(blockIdx)")
+[__readNone]
 uint3 cudaBlockIdx();
 
 __target_intrinsic(cuda, "(blockDim)")
+[__readNone]
 uint3 cudaBlockDim();
diff --git a/source/slang/slang-emit-c-like.cpp b/source/slang/slang-emit-c-like.cpp
index ebc312560..2bc739142 100644
--- a/source/slang/slang-emit-c-like.cpp
+++ b/source/slang/slang-emit-c-like.cpp
@@ -2407,6 +2407,17 @@ void CLikeSourceEmitter::_emitInst(IRInst* inst)
         {
             auto type = inst->getDataType();
             emitType(type, getName(inst));
+
+            // On targets that support empty initializers, we will emit it.
+            switch (this->getTarget())
+            {
+            case CodeGenTarget::CPPSource:
+            case CodeGenTarget::HostCPPSource:
+            case CodeGenTarget::PyTorchCppBinding:
+            case CodeGenTarget::CUDASource:
+                m_writer->emit(" = {}");
+                break;
+            }
             m_writer->emit(";\n");
         }
         break;
diff --git a/source/slang/slang-emit.cpp b/source/slang/slang-emit.cpp
index 6a0f46e0a..a18eed928 100644
--- a/source/slang/slang-emit.cpp
+++ b/source/slang/slang-emit.cpp
@@ -475,7 +475,6 @@ Result linkAndOptimizeIR(
 
     // We don't need the legalize pass for C/C++ based types
     if(options.shouldLegalizeExistentialAndResourceTypes )
-//    if (!(sourceLanguage == SourceLanguage::CPP || sourceStyle == SourceLanguage::C))
     {
         // The Slang language allows interfaces to be used like
         // ordinary types (including placing them in constant
@@ -534,6 +533,20 @@ Result linkAndOptimizeIR(
     #endif
         validateIRModuleIfEnabled(codeGenContext, irModule);
     }
+    else
+    {
+#if 0
+        // On CPU/CUDA targets, we simply elminate any empty types.
+        // TODO: disable for now, since the CPU compute shader
+        // trampoline is still hard coded to assume there are
+        // entrypoint and global parameters. renable when
+        // we fix that logic.
+        legalizeEmptyTypes(
+            irModule,
+            sink);
+        eliminateDeadCode(irModule);
+#endif
+    }
 
     // Once specialization and type legalization have been performed,
     // we should perform some of our basic optimization steps again,
diff --git a/source/slang/slang-ir-cleanup-void.cpp b/source/slang/slang-ir-cleanup-void.cpp
index 78ca823e5..47d982950 100644
--- a/source/slang/slang-ir-cleanup-void.cpp
+++ b/source/slang/slang-ir-cleanup-void.cpp
@@ -139,6 +139,9 @@ namespace Slang
             case kIROp_GetTupleElement:
             case kIROp_GetResultError:
             case kIROp_GetResultValue:
+            case kIROp_Call:
+            case kIROp_UpdateElement:
+            case kIROp_GetTargetTupleElement:
                 if (inst->getDataType()->getOp() == kIROp_VoidType)
                 {
                     IRBuilder builder(module);
diff --git a/source/slang/slang-ir-legalize-types.cpp b/source/slang/slang-ir-legalize-types.cpp
index ef7b74906..9131a3559 100644
--- a/source/slang/slang-ir-legalize-types.cpp
+++ b/source/slang/slang-ir-legalize-types.cpp
@@ -3766,6 +3766,23 @@ struct IRExistentialTypeLegalizationContext : IRTypeLegalizationContext
     }
 };
 
+struct IREmptyTypeLegalizationContext : IRTypeLegalizationContext
+{
+    IREmptyTypeLegalizationContext(IRModule* module)
+        : IRTypeLegalizationContext(module)
+    {}
+
+    bool isSpecialType(IRType*) override
+    {
+        return false;
+    }
+
+    LegalType createLegalUniformBufferType(IROp, LegalType) override
+    {
+        return LegalType();
+    }
+};
+
 // The main entry points that are used when transforming IR code
 // to get it ready for lower-level codegen are then simple
 // wrappers around `legalizeTypes()` that pick an appropriately
@@ -3792,5 +3809,13 @@ void legalizeExistentialTypeLayout(
     legalizeTypes(&context);
 }
 
+void legalizeEmptyTypes(IRModule* module, DiagnosticSink* sink)
+{
+    SLANG_UNUSED(sink);
+
+    IREmptyTypeLegalizationContext context(module);
+    legalizeTypes(&context);
+}
+
 
 }
diff --git a/source/slang/slang-ir.cpp b/source/slang/slang-ir.cpp
index 76e889780..a4d7840d3 100644
--- a/source/slang/slang-ir.cpp
+++ b/source/slang/slang-ir.cpp
@@ -7191,6 +7191,11 @@ namespace Slang
         case kIROp_Reinterpret:
         case kIROp_GetNativePtr:
         case kIROp_BackwardDiffIntermediateContextType:
+        case kIROp_MakeTargetTuple:
+        case kIROp_GetTargetTupleElement:
+        case kIROp_TorchGetCudaStream:
+        case kIROp_MakeTensorView:
+        case kIROp_TorchTensorGetView:
             return false;
 
         case kIROp_ForwardDifferentiate:
diff --git a/source/slang/slang-legalize-types.h b/source/slang/slang-legalize-types.h
index 693a154f6..fd8176889 100644
--- a/source/slang/slang-legalize-types.h
+++ b/source/slang/slang-legalize-types.h
@@ -695,6 +695,10 @@ void legalizeResourceTypes(
     IRModule*       module,
     DiagnosticSink* sink);
 
+void legalizeEmptyTypes(
+    IRModule* module,
+    DiagnosticSink* sink);
+
 bool isResourceType(IRType* type);