From 73a61edda8893901acad05bb4e7d3110db5041a8 Mon Sep 17 00:00:00 2001
From: Yong He <yonghe@outlook.com>
Date: Wed, 28 Feb 2024 22:57:07 -0800
Subject: [SPIRV] Add NonSemanticDebugInfo for step-through debugging. (#3644)

* [SPIRV] Add NonSemanticDebugInfo for step-through debugging.

* Fix.

* Fix.
---
 source/slang/slang-ir-legalize-types.cpp | 88 ++++++++++++++++++++++++++++++++
 1 file changed, 88 insertions(+)

(limited to 'source/slang/slang-ir-legalize-types.cpp')

diff --git a/source/slang/slang-ir-legalize-types.cpp b/source/slang/slang-ir-legalize-types.cpp
index 6c5ab1223..93715bc36 100644
--- a/source/slang/slang-ir-legalize-types.cpp
+++ b/source/slang/slang-ir-legalize-types.cpp
@@ -814,6 +814,87 @@ static LegalVal legalizeLoad(
     }
 }
 
+static LegalVal legalizeDebugVar(IRTypeLegalizationContext* context, LegalType type, IRDebugVar* originalInst)
+{
+    // For now we just discard any special part and keep the ordinary part.
+
+    switch (type.flavor)
+    {
+    case LegalType::Flavor::simple:
+    {
+        auto legalVal = context->builder->emitDebugVar(
+            type.getSimple(),
+            originalInst->getSource(),
+            originalInst->getLine(),
+            originalInst->getCol());
+        copyNameHintAndDebugDecorations(legalVal, originalInst);
+        return LegalVal::simple(legalVal);
+    }
+    case LegalType::Flavor::none:
+        return LegalVal();
+    case LegalType::Flavor::pair:
+        {
+            auto pairType = type.getPair();
+            auto ordinaryVal = legalizeDebugVar(context, pairType->ordinaryType, originalInst);
+            return ordinaryVal;
+        }
+    case LegalType::Flavor::tuple:
+        {
+            auto tupleType = type.getTuple();
+            for (auto ee : tupleType->elements)
+            {
+                auto innerResult = legalizeDebugVar(context, ee.type, originalInst);
+                if (innerResult.flavor != LegalVal::Flavor::none)
+                    return innerResult;
+            }
+            return LegalVal();
+        }
+    default:
+        return LegalVal();
+    }
+}
+
+static LegalVal legalizeDebugValue(IRTypeLegalizationContext* context, LegalVal debugVar, LegalVal debugValue, IRDebugValue* originalInst)
+{
+    // For now we just discard any special part and keep the ordinary part.
+    List<IRInst*> accessChain;
+    for (UInt i = 0; i < originalInst->getAccessChainCount(); i++)
+    {
+        accessChain.add(originalInst->getAccessChain(i));
+    }
+    switch (debugValue.flavor)
+    {
+    case LegalType::Flavor::simple:
+        return LegalVal::simple(
+            context->builder->emitDebugValue(
+                debugVar.getSimple(),
+                debugValue.getSimple(),
+                accessChain.getArrayView()));
+    case LegalType::Flavor::none:
+        return LegalVal();
+    case LegalType::Flavor::pair:
+    {
+        auto ordinaryVal = legalizeDebugValue(context, debugVar, debugValue.getPair()->ordinaryVal, originalInst);
+        return ordinaryVal;
+    }
+    case LegalType::Flavor::tuple:
+    {
+        auto tupleVar = debugVar.getTuple();
+        UInt index = 0;
+        for (auto ee : tupleVar->elements)
+        {
+            auto innerResult = legalizeDebugValue(context, debugVar, debugValue.getTuple()->elements[index].val, originalInst);
+            if (innerResult.flavor != LegalVal::Flavor::none)
+                return innerResult;
+            index++;
+        }
+        return LegalVal();
+    }
+    default:
+        return LegalVal();
+    }
+}
+
 static LegalVal legalizeStore(
     IRTypeLegalizationContext*    context,
     LegalVal                    legalPtrVal,
@@ -1921,6 +2002,12 @@ static LegalVal legalizeInst(
         return legalizeCall(context, (IRCall*)inst);
     case kIROp_Return:
         return legalizeRetVal(context, args[0], (IRReturn*)inst);
+
+    case kIROp_DebugVar:
+        return legalizeDebugVar(context, type, (IRDebugVar*)inst);
+    case kIROp_DebugValue:
+        return legalizeDebugValue(context, args[0], args[1], (IRDebugValue*)inst);
+
     case kIROp_MakeStruct:
         return legalizeMakeStruct(
             context,
@@ -1939,6 +2026,7 @@ static LegalVal legalizeInst(
         return legalizeDefaultConstruct(
             context,
             type);
+
     case kIROp_unconditionalBranch:
     case kIROp_loop:
         return legalizeUnconditionalBranch(context, args, (IRUnconditionalBranch*)inst);
-- 
cgit v1.2.3