Various Fixes to gfx, reflection and emit. (shader-slang#1867)

* Various Fixes to gfx, reflection and emit.

- Fix GLSL emit to properly output `*bitsTo*` functions for `IRBitCast` insts.

- Add line directive mode setting for `ISession`.

- Extend `TypeLayout::getElementStride` to handle `VectorType` case.

- Fix `IDevice::readBufferResource` 's D3D12  implementation to copy only the requested bytes out.

- Fix `render-test` to use the `ISession` from `gfx` instead of creating its own `ISession` to make sure `gfx` and `render-test` agree on WitnessTable and RTTI IDs.

- Extend `render-test` to support filling vector and matrix values in the new `set x = ...` TEST_INPUT syntax.

- Add a `dynamic-dispatch-15` test case to make sure packing / unpacking works correctly across all targets, and to make sure render-test's RTTI/WitnessTable ID filling logic is correct for non-trivial cases.

* Remove default-major test

* Fix cyclic reference in `ExtendedTypeLayout`.

* Move `lineDirectiveMode` setting to `TargetDesc`.

Add `structureSize` to `TargetDesc` and `SessionDesc` for future binary compatibility.

* Cleanup.

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

Author: csyonghe

slang-gfx.h

@@ -1140,6 +1140,7 @@ class IDevice: public ISlangUnknown
         SlangFloatingPointMode floatingPointMode = SLANG_FLOATING_POINT_MODE_DEFAULT;
         SlangOptimizationLevel optimizationLevel = SLANG_OPTIMIZATION_LEVEL_DEFAULT;
         SlangTargetFlags targetFlags = 0;
+        SlangLineDirectiveMode lineDirectiveMode = SLANG_LINE_DIRECTIVE_MODE_DEFAULT;
     };
 
     struct Desc

slang.h

@@ -1317,10 +1317,17 @@ extern "C"
         SlangCompileRequest*    request,
         const char* prefix);
 
-    /*! @see slang::ICompileRequest::setLineDirectiveMode */
+    /*! DEPRECATED: use `spSetTargetLineDirectiveMode` instead.
+        @see slang::ICompileRequest::setLineDirectiveMode */
     SLANG_API void spSetLineDirectiveMode(
         SlangCompileRequest*    request,
         SlangLineDirectiveMode  mode);
+        
+    /*! @see slang::ICompileRequest::setTargetLineDirectiveMode */
+    SLANG_API void spSetTargetLineDirectiveMode(
+        SlangCompileRequest*    request,
+        int targetIndex,
+        SlangLineDirectiveMode  mode);
 
     /*! @see slang::ICompileRequest::setCodeGenTarget */
     SLANG_API void spSetCodeGenTarget(
@@ -3784,6 +3791,11 @@ namespace slang
         virtual SLANG_NO_THROW SlangResult SLANG_MCALL getProgramWithEntryPoints(
             slang::IComponentType** outProgram) = 0;
 
+            /** Set the line directive mode for a target.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL setTargetLineDirectiveMode(
+            SlangInt targetIndex,
+            SlangLineDirectiveMode mode) = 0;
     };
 
     #define SLANG_UUID_ICompileRequest ICompileRequest::getTypeGuid()
@@ -3792,6 +3804,10 @@ namespace slang
         */
     struct TargetDesc
     {
+            /** The size of this structure, in bytes.
+            */
+        size_t structureSize = sizeof(TargetDesc);
+
             /** The target format to generate code for (e.g., SPIR-V, DXIL, etc.)
             */
         SlangCompileTarget      format = SLANG_TARGET_UNKNOWN;
@@ -3810,6 +3826,10 @@ namespace slang
             /** Optimization level to use for the target.
             */
         SlangOptimizationLevel optimizationLevel = SLANG_OPTIMIZATION_LEVEL_DEFAULT;
+
+            /** The line directive mode for output source code.
+            */
+        SlangLineDirectiveMode lineDirectiveMode = SLANG_LINE_DIRECTIVE_MODE_DEFAULT;
     };
 
     typedef uint32_t SessionFlags;
@@ -3836,6 +3856,10 @@ namespace slang
 
     struct SessionDesc
     {
+            /** The size of this structure, in bytes.
+             */
+        size_t structureSize = sizeof(SessionDesc);
+
             /** Code generation targets to include in the session.
             */
         TargetDesc const*   targets = nullptr;
@@ -3856,7 +3880,6 @@ namespace slang
 
         PreprocessorMacroDesc const*    preprocessorMacros = nullptr;
         SlangInt                        preprocessorMacroCount = 0;
-
     };
 
     enum class ContainerType

source/slang/slang-api.cpp

@@ -272,6 +272,15 @@ SLANG_API void spSetLineDirectiveMode(
     request->setLineDirectiveMode(mode);
 }
 
+SLANG_API void spSetTargetLineDirectiveMode(
+    slang::ICompileRequest* request,
+    int targetIndex,
+    SlangLineDirectiveMode mode)
+{
+    SLANG_ASSERT(request);
+    request->setTargetLineDirectiveMode(targetIndex, mode);
+}
+
 SLANG_API void spSetCommandLineCompilerMode(
     slang::ICompileRequest* request)
 {

source/slang/slang-compiler.cpp

@@ -1961,7 +1961,6 @@ namespace Slang
             m_program->getLinkage(),
             sink,
             m_program);
-
         backEndRequest->shouldDumpIR =
             (m_targetReq->getTargetFlags() & SLANG_TARGET_FLAG_DUMP_IR) != 0;
 

source/slang/slang-compiler.h

@@ -1178,6 +1178,10 @@ namespace Slang
         {
             floatingPointMode = mode;
         }
+        void setLineDirectiveMode(LineDirectiveMode mode)
+        {
+            lineDirectiveMode = mode;
+        }
         void addCapability(CapabilityAtom capability);
 
 
@@ -1190,6 +1194,7 @@ namespace Slang
         CodeGenTarget getTarget() { return format; }
         Profile getTargetProfile() { return targetProfile; }
         FloatingPointMode getFloatingPointMode() { return floatingPointMode; }
+        LineDirectiveMode getLineDirectiveMode() { return lineDirectiveMode; }
         SlangTargetFlags getTargetFlags() { return targetFlags; }
         CapabilitySet getTargetCaps();
 
@@ -1211,6 +1216,7 @@ namespace Slang
         FloatingPointMode       floatingPointMode = FloatingPointMode::Default;
         List<CapabilityAtom>    rawCapabilities;
         CapabilitySet           cookedCapabilities;
+        LineDirectiveMode       lineDirectiveMode = LineDirectiveMode::Default;
     };
 
         /// Are we generating code for a D3D API?
@@ -1867,11 +1873,6 @@ namespace Slang
         // Should we dump intermediate results along the way, for debugging?
         bool shouldDumpIntermediates = false;
 
-        // How should `#line` directives be emitted (if at all)?
-        LineDirectiveMode lineDirectiveMode = LineDirectiveMode::Default;
-
-        LineDirectiveMode getLineDirectiveMode() { return lineDirectiveMode; }
-
         ComponentType* getProgram() { return m_program; }
         void setProgram(ComponentType* program) { m_program = program; }
 
@@ -1976,7 +1977,9 @@ namespace Slang
         virtual SLANG_NO_THROW void SLANG_MCALL setCommandLineCompilerMode() SLANG_OVERRIDE;
         virtual SLANG_NO_THROW SlangResult SLANG_MCALL addTargetCapability(SlangInt targetIndex, SlangCapabilityID capability) SLANG_OVERRIDE;
         virtual SLANG_NO_THROW SlangResult SLANG_MCALL getProgramWithEntryPoints(slang::IComponentType** outProgram) SLANG_OVERRIDE;
-
+        virtual SLANG_NO_THROW void SLANG_MCALL setTargetLineDirectiveMode(
+            SlangInt targetIndex,
+            SlangLineDirectiveMode mode) SLANG_OVERRIDE;
 
         EndToEndCompileRequest(
             Session* session);
@@ -2018,6 +2021,11 @@ namespace Slang
             /// A blob holding the diagnostic output
         ComPtr<ISlangBlob> m_diagnosticOutputBlob;
 
+            /// Line directive mode for new targets to be added to this request.
+            /// This is needed to support the legacy `setLineDirectiveMode` API.
+            /// We can remove this field if we move to `setTargetLineDirectiveMode`.
+        LineDirectiveMode m_lineDirectiveMode = LineDirectiveMode::Default;
+
             /// Per-entry-point information not tracked by other compile requests
         class EntryPointInfo : public RefObject
         {
@@ -2083,7 +2091,11 @@ namespace Slang
         {
             return m_specializedEntryPoints[index];
         }
-
+        ~EndToEndCompileRequest()
+        {
+            m_linkage = nullptr;
+            m_frontEndReq = nullptr;
+        }
     private:
 
         ISlangUnknown* getInterface(const Guid& guid);

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

@@ -195,7 +195,6 @@ class CLikeSourceEmitter: public RefObject
 
         /// Get the diagnostic sink
     DiagnosticSink* getSink() { return m_compileRequest->getSink();}
-    LineDirectiveMode getLineDirectiveMode() { return m_compileRequest->getLineDirectiveMode(); }
 
         /// Get the code gen target
     CodeGenTarget getTarget() { return m_target; }

source/slang/slang-emit-glsl.cpp

@@ -1404,21 +1404,48 @@ bool GLSLSourceEmitter::tryEmitInstExprImpl(IRInst* inst, const EmitOpInfo& inOu
         case kIROp_BitCast:
         {
             auto toType = extractBaseType(inst->getDataType());
+            auto fromType = extractBaseType(inst->getOperand(0)->getDataType());
             switch (toType)
             {
                 default:
                     diagnoseUnhandledInst(inst);
                     break;
 
                 case BaseType::UInt:
+                    if (fromType == BaseType::Float)
+                    {
+                        m_writer->emit("floatBitsToUint");
+                    }
+                    else
+                    {
+                        emitType(inst->getDataType());
+                    }
                     break;
 
                 case BaseType::Int:
-                    emitType(inst->getDataType());
+                    if (fromType == BaseType::Float)
+                    {
+                        m_writer->emit("floatBitsToInt");
+                    }
+                    else
+                    {
+                        emitType(inst->getDataType());
+                    }
                     break;
 
                 case BaseType::Float:
-                    m_writer->emit("uintBitsToFloat");
+                    switch (fromType)
+                    {
+                    case BaseType::Int:
+                        m_writer->emit("intBitsToFloat");
+                        break;
+                    case BaseType::UInt:
+                        m_writer->emit("uintBitsToFloat");
+                        break;
+                    default:
+                        emitType(inst->getDataType());
+                        break;
+                    }
                     break;
             }
 

source/slang/slang-emit.cpp

@@ -729,7 +729,7 @@ SlangResult emitEntryPointsSourceFromIR(
     auto sink = compileRequest->getSink();
     auto program = compileRequest->getProgram();
 
-    auto lineDirectiveMode = compileRequest->getLineDirectiveMode();
+    auto lineDirectiveMode = targetRequest->getLineDirectiveMode();
     // To try to make the default behavior reasonable, we will
     // always use C-style line directives (to give the user
     // good source locations on error messages from downstream

source/slang/slang-reflection-api.cpp

@@ -946,6 +946,12 @@ SLANG_API size_t spReflectionTypeLayout_GetElementStride(SlangReflectionTypeLayo
             return 0;
         }
     }
+    else if (auto vectorTypeLayout = as<VectorTypeLayout>(typeLayout))
+    {
+        auto resInfo = vectorTypeLayout->elementTypeLayout->FindResourceInfo(LayoutResourceKind::Uniform);
+        if (!resInfo) return 0;
+        return resInfo->count.getFiniteValue();
+    }
 
     return 0;
 }
@@ -971,7 +977,14 @@ SLANG_API SlangReflectionTypeLayout* spReflectionTypeLayout_GetElementTypeLayout
     {
         return convert(specializedTypeLayout->baseTypeLayout.Ptr());
     }
-
+    else if (auto vectorTypeLayout = as<VectorTypeLayout>(typeLayout))
+    {
+        return convert(vectorTypeLayout->elementTypeLayout);
+    }
+    else if (auto matrixTypeLayout = as<MatrixTypeLayout>(typeLayout))
+    {
+        return convert(matrixTypeLayout->elementTypeLayout);
+    }
     return nullptr;
 }
 

source/slang/slang-repro.cpp

@@ -363,7 +363,6 @@ static String _scrubName(const String& in)
 
         dst->compileFlags = request->getFrontEndReq()->compileFlags;
         dst->shouldDumpIntermediates = request->getBackEndReq()->shouldDumpIntermediates;
-        dst->lineDirectiveMode = request->getBackEndReq()->lineDirectiveMode;
 
         dst->debugInfoLevel = linkage->debugInfoLevel;
         dst->optimizationLevel = linkage->optimizationLevel;

source/slang/slang.cpp

@@ -445,9 +445,16 @@ SLANG_NO_THROW SlangResult SLANG_MCALL Session::createSession(
     RefPtr<Linkage> linkage = new Linkage(this, astBuilder, getBuiltinLinkage());
 
     Int targetCount = desc.targetCount;
+    const uint8_t* targetDescPtr = reinterpret_cast<const uint8_t*>(desc.targets);
     for(Int ii = 0; ii < targetCount; ++ii)
     {
-        linkage->addTarget(desc.targets[ii]);
+        slang::TargetDesc targetDesc;
+        // Copy the size field first.
+        memcpy(&targetDesc.structureSize, targetDescPtr, sizeof(size_t));
+        // Copy the entire desc structure.
+        memcpy(&targetDesc, targetDescPtr, targetDesc.structureSize);
+        linkage->addTarget(targetDesc);
+        targetDescPtr += targetDesc.structureSize;
     }
 
     if(desc.flags & slang::kSessionFlag_FalcorCustomSharedKeywordSemantics)
@@ -793,6 +800,7 @@ void Linkage::addTarget(
     target->setFloatingPointMode(FloatingPointMode(desc.floatingPointMode));
     target->addTargetFlags(desc.flags);
     target->setTargetProfile(Profile(desc.profile));
+    target->setLineDirectiveMode(LineDirectiveMode(desc.lineDirectiveMode));
 }
 
 #if 0
@@ -1034,6 +1042,7 @@ SLANG_NO_THROW SlangResult SLANG_MCALL Linkage::createCompileRequest(
     SlangCompileRequest**   outCompileRequest)
 {
     auto compileRequest = new EndToEndCompileRequest(this);
+    compileRequest->addRef();
     *outCompileRequest = asExternal(compileRequest);
     return SLANG_OK;
 }
@@ -1060,7 +1069,6 @@ SlangResult Linkage::setMatrixLayoutMode(
     return SLANG_OK;
 }
 
-
 //
 // TargetRequest
 //
@@ -2009,7 +2017,9 @@ BackEndCompileRequest::BackEndCompileRequest(
     : CompileRequestBase(linkage, sink)
     , m_program(program)
     , m_dumpIntermediatePrefix("slang-dump-")
-{}
+
+{
+}
 
 EndToEndCompileRequest::EndToEndCompileRequest(
     Session* session)
@@ -3840,8 +3850,16 @@ void EndToEndCompileRequest::setDumpIntermediatePrefix(const char* prefix)
 
 void EndToEndCompileRequest::setLineDirectiveMode(SlangLineDirectiveMode mode)
 {
-    // TODO: validation
-    getBackEndReq()->lineDirectiveMode = LineDirectiveMode(mode);
+    // This method is deprecated and user should call `setTargetLineDirectiveMode` instead.
+    // We provide the implementation here for backward compatibility.
+    // Targets added later will use `m_lineDirectiveMode`, so we update it to the new `mode`
+    // set by the user.
+    m_lineDirectiveMode = LineDirectiveMode(mode);
+
+    // Change all existing targets to use the new mode.
+    auto linkage = getLinkage();
+    for (auto& target : linkage->targets)
+        target->setLineDirectiveMode(m_lineDirectiveMode);
 }
 
 void EndToEndCompileRequest::setCommandLineCompilerMode()
@@ -3854,11 +3872,14 @@ void EndToEndCompileRequest::setCodeGenTarget(SlangCompileTarget target)
     auto linkage = getLinkage();
     linkage->targets.clear();
     linkage->addTarget(CodeGenTarget(target));
+    linkage->targets[0]->setLineDirectiveMode(m_lineDirectiveMode);
 }
 
 int EndToEndCompileRequest::addCodeGenTarget(SlangCompileTarget target)
 {
-    return (int)getLinkage()->addTarget(CodeGenTarget(target));
+    int targetIndex = (int)getLinkage()->addTarget(CodeGenTarget(target));
+    getLinkage()->targets[targetIndex]->setLineDirectiveMode(m_lineDirectiveMode);
+    return targetIndex;
 }
 
 void EndToEndCompileRequest::setTargetProfile(int targetIndex, SlangProfileID profile)
@@ -3887,6 +3908,13 @@ void EndToEndCompileRequest::setTargetMatrixLayoutMode(int targetIndex, SlangMat
     setMatrixLayoutMode(mode);
 }
 
+void EndToEndCompileRequest::setTargetLineDirectiveMode(
+    SlangInt targetIndex,
+    SlangLineDirectiveMode mode)
+{
+    getLinkage()->targets[targetIndex]->setLineDirectiveMode(LineDirectiveMode(mode));
+}
+
 SlangResult EndToEndCompileRequest::addTargetCapability(SlangInt targetIndex, SlangCapabilityID capability)
 {
     auto& targets = getLinkage()->targets;